Рубрики
go

008 / go var / Объявление переменных / Нулевые значения / Короткие объявления переменных / преобразования

В языке 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)