В языке Go переменная представляет собой область памяти, в которой хранится значение.
Чтобы к переменной можно было обращаться по имени, используйте объявление переменной.
Объявление состоит из ключевого слова var, за которым следует имя и тип значений, которые будут храниться в переменной.
var quantity int
var length, width float64
var customerName string
После того как переменная будет объявлена, ей можно будет присвоить любое значение этого типа оператором = (один знак равенства):
quantity = 2
customerName = "Damon Cole"
В одной команде можно присвоить значения сразу нескольким переменным.
Для этого перечислите имена переменных слева от = и такое же количество значений в правой части, разделяя их запятыми.
length, width = 1.2, 2.4
После того как переменной будет присвоено значение, вы сможете использовать ее в любом контексте, где может использоваться исходное значение:
package main
import "fmt"
func main() {
var quantity int
var length, width float64
var customerName string
quantity = 4
length, width = 1.2, 2.4
customerName = "Damon Cole"
fmt.Println(customerName)
fmt.Println("has ordered", quantity, "sheets")
fmt.Println("each with an area of")
fmt.Println(length*width, "square meters")
}
Пример 2:
package main
import "fmt"
func main() {
var x1 int
var x2 int
var sumx int
x1 = 500
x2 = 600
sumx = x1+x2
fmt.Println(x1, "+", x2, "=", sumx)
}
Если значение переменной известно заранее, можно объявить переменную и присвоить ей значение в одной строке:
var quantity int = 4
var length, width float64 = 1.2, 2.4
var customerName string = "Damon Cole"
Существующим переменным можно присваивать новые значения, но эти значения должны относиться к тому же типу.
Статическая типизация в Go гарантирует, что переменной не будет случайно присвоено значение неподходящего типа.
Если значение переменной присваивается одновременно с ее объявлением, тип переменной в объявлении обычно не указывают.
Тип значения, присвоенного переменной, будет считаться типом этой переменной.
var quantity = 4
var length, width = 1.2, 2.4
var customerName = "Damon Cole"
fmt.Println(reflect.TypeOf(quantity))
fmt.Println(reflect.TypeOf(length))
fmt.Println(reflect.TypeOf(width))
fmt.Println(reflect.TypeOf(customerName))
Пример:
package main
import "fmt"
func main() {
var x1 int = 700
var x2 int = 800
var sumx = x1+x2
fmt.Println(x1, "+", x2, "=", sumx)
}
Нулевые значения
Если переменная объявляется без присваивания значения, то она будет содержать нулевое значение для этого типа.
Для числовых типов нулевое значение равно 0.
Пример:
package main
import "fmt"
func main() {
var myInt int
var myFloat float64
fmt.Println(myInt, myFloat)
}
Но для других типов значение 0 будет недействительным, поэтому нулевое значение для этого типа будет отличаться.
Скажем, для строковых переменных нулевым значением является пустая строка, а для переменных bool — значение false.
Пример:
package main
import "fmt"
func main() {
var myString string
var myBool bool
fmt.Println(myString, myBool)
}
Короткие объявления переменных
Вместо того чтобы явно объявлять тип переменной и позднее присваивать ей значение оператором =,
вы совмещаете эти две операции с помощью синтаксиса :=.
Обычное объявление переменной выглядит вот так:
var quantity int = 4
var length, width float64 = 1.2, 2.4
var customerName string = "Damon Cole"
Короткие объявления переменных выглядит так:
quantity := 4
length, width := 1.2, 2.4
customerName := "Damon Cole"
Пример в коде:
package main
import "fmt"
func main() {
quantity := 4
length, width := 1.2, 2.4
customerName := "Damon Cole"
fmt.Println(customerName)
fmt.Println("has ordered", quantity, "sheets")
fmt.Println("each with an area of")
fmt.Println(length*width, "square meters")
}
Явно объявлять тип переменной не обязательно:
тип значения,
присвоенного переменной,
становится типом этой переменной.
Поскольку короткие объявления переменных очень удобны и компактны, они используются чаще обычных объявлений.
Впрочем, время от времени вам будут встречаться обе формы, поэтому важно знать их.
Правила выбора имен для переменных
В Go существует один простой набор правил, применяемых к именам переменных, функций и типов: !!! Эти правила должны обязательно выполняться на уровне языка 00. Имя должно начинаться с буквы и может содержать любое количество дополнительных букв и цифр. 01. Если имя переменной, функции или типа начинается с буквы верхнего регистра, оно считается экспортируемым и может использоваться в других пакетах, кроме текущего. (Именно поэтому буква P в fmt.Println имеет верхний регистр: это нужно для того, чтобы его можно было использовать в main или любом другом пакете.) Если имя переменной/функции/типа начинается с буквы нижнего регистра, оно считается не экспортируемым. Такие имена доступны только в текущем пакете. !!! Но сообщество Go также соблюдает ряд дополнительных соглашений: 02. Если имя состоит из нескольких слов, каждое слово после первого должно начинаться с буквы верхнего регистра, и они должны следовать друг за другом без разделения пробелами: topPrice, RetryConnection и т. д. (Первая буква имени имеет верхний регистр только в том случае, если оно должно экспортироваться из пакета.) Этот стиль записи часто называется верблюжьим регистром, потому что буквы верхнего регистра напоминают горбы у верблюда. 03. Если смысл имени очевиден по контексту, в сообществе Go принято сокращать его: использовать i вместо index, max вместо maximum и т. д. Примеры: Нормально: sheetLength TotalUnits i нарушают соглашения: sheetlength - Остальные слова должны начинаться с буквы верхнего регистра! Total_Units - Допустимо, но слова должны записываться подряд! index - Хорошо бы заменить сокращением! !!! Только переменные, функции и типы, имена которых начинаются с буквы верхнего регистра, считаются экспортируемыми, то есть доступными за пределами текущего пакета.
Преобразование переменных
Пример не рабочего кода:
package main
import "fmt"
func main() {
var length float64 = 1.2
var width int = 2
fmt.Println("Area is", length*width)
fmt.Println("length > width?", length > width)
}
Исправим код:
package main
import "fmt"
func main() {
var length float64 = 1.2
var width int = 2
fmt.Println("Area is", length*float64(width))
fmt.Println("length > width?", length > float64(width))
}
Теперь математические операции и операции сравнения работают правильно!
Попробуем преобразовать значение int к типу float64 перед присваиванием переменной float64:
var length float64 = 1.2
var width int = 2
length = float64(width) - Преобразование int к типу float64 перед присваиванием переменной float64
fmt.Println(length)
Всегда держите в голове, как преобразования изменяют выходные значения.
Например, переменные float64 могут хранить дробные значения, а переменные int — нет.
Когда вы преобразовываете float64 в int, дробная часть просто отбрасывается!
Это может внести путаницу в любые операции, выполняемые с результирующим значением.
var length float64 = 3.75
var width int = 5
width = int(length) - В результате этого преобразования дробная часть теряется!
fmt.Println(width)
Но если действовать внимательно, вы поймете, что преобразования исключительно важны для работы с Go.
С ними вы сможете совместно использовать несовместимые типы.
Пример:
var price int = 100
var taxRate float64 = 0.08
var tax float64 = float64(price) * taxRate
fmt.Println(tax)