Go - переменные

Переменная - это не что иное, как имя, присвоенное области хранения, которой могут управлять программы. Каждая переменная в Go имеет определенный тип, который определяет размер и структуру памяти переменной, диапазон значений, которые могут быть сохранены в этой памяти, и набор операций, которые могут быть применены к переменной.

Имя переменной может состоять из букв, цифр и символа подчеркивания. Он должен начинаться либо с буквы, либо с подчеркивания. Прописные и строчные буквы различаются, поскольку в Go учитывается регистр. На основе основных типов, описанных в предыдущей главе, будут следующие основные типы переменных:

Старший Нет	Тип и описание
1	byte Обычно один октет (один байт). Это байтовый тип.
2	int Самый естественный размер целого числа для машины.
3	float32 Значение с плавающей запятой одинарной точности.

Язык программирования Go также позволяет определять различные другие типы переменных, такие как Enumeration, Pointer, Array, Structure и Union, которые мы обсудим в следующих главах. В этой главе мы сосредоточимся только на основных типах переменных.

Определение переменной в Go

Определение переменной сообщает компилятору, где и сколько памяти следует создать для переменной. Определение переменной указывает тип данных и содержит список из одной или нескольких переменных этого типа следующим образом:

var variable_list optional_data_type;

Вот, optional_data_type является допустимым типом данных Go, включая byte, int, float32, complex64, boolean или любой пользовательский объект и т. д., и variable_listможет состоять из одного или нескольких имен идентификаторов, разделенных запятыми. Здесь показаны некоторые действительные декларации -

var  i, j, k int;
var  c, ch byte;
var  f, salary float32;
d =  42;

Заявление “var i, j, k;”объявляет и определяет переменные i, j и k; который инструктирует компилятор создать переменные с именами i, j и k типа int.

Переменные могут быть инициализированы (присвоено начальное значение) в их объявлении. Тип переменной автоматически определяется компилятором на основании переданного ему значения. Инициализатор состоит из знака равенства, за которым следует постоянное выражение:

variable_name = value;

Например,

d = 3, f = 5;    // declaration of d and f. Here d and f are int

Для определения без инициализатора: переменные со статической продолжительностью хранения неявно инициализируются значением nil (все байты имеют значение 0); начальное значение всех остальных переменных - нулевое значение их типа данных.

Объявление статического типа в Go

Объявление переменной статического типа обеспечивает компилятору гарантию того, что существует одна доступная переменная с данным типом и именем, так что компилятор может продолжить компиляцию, не требуя полной информации о переменной. Объявление переменной имеет смысл только во время компиляции, компилятору требуется фактическое объявление переменной во время связывания программы.

пример

Попробуйте следующий пример, где переменная была объявлена с типом и инициализирована внутри основной функции:

package main

import "fmt"

func main() {
   var x float64
   x = 20.0
   fmt.Println(x)
   fmt.Printf("x is of type %T\n", x)
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат:

20
x is of type float64

Объявление динамического типа / вывод типа в Go

Объявление переменной динамического типа требует, чтобы компилятор интерпретировал тип переменной на основе переданного ей значения. Компилятор не требует, чтобы переменная имела статический тип как необходимое требование.

пример

Попробуйте следующий пример, где переменные объявлены без какого-либо типа. Обратите внимание: в случае вывода типа мы инициализировали переменнуюy с оператором: =, тогда как x инициализируется с помощью оператора =.

package main

import "fmt"

func main() {
   var x float64 = 20.0

   y := 42 
   fmt.Println(x)
   fmt.Println(y)
   fmt.Printf("x is of type %T\n", x)
   fmt.Printf("y is of type %T\n", y)	
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат:

20
42
x is of type float64
y is of type int

Объявление смешанных переменных в Go

Переменные разных типов могут быть объявлены за один раз, используя вывод типа.

пример

package main

import "fmt"

func main() {
   var a, b, c = 3, 4, "foo"  
	
   fmt.Println(a)
   fmt.Println(b)
   fmt.Println(c)
   fmt.Printf("a is of type %T\n", a)
   fmt.Printf("b is of type %T\n", b)
   fmt.Printf("c is of type %T\n", c)
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат:

3
4
foo
a is of type int
b is of type int
c is of type string

Lvalues и rvalues в Go

В Go есть два вида выражений:

lvalue- Выражение, относящееся к области памяти, называется выражением «lvalue». Lvalue может отображаться как левая или правая часть присваивания.
rvalue- Термин rvalue относится к значению данных, которое хранится по некоторому адресу в памяти. Rvalue - это выражение, которому не может быть присвоено значение, что означает, что rvalue может появляться справа, но не слева от присваивания.

Переменные - это lvalue, поэтому они могут появляться в левой части присваивания. Числовые литералы являются r-значениями, поэтому не могут быть присвоены и не могут отображаться в левой части.

Следующее утверждение действительно -