Переменные

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

Прежде чем что-то положить в коробку, её нужно завести и подписать. Go требует объявить переменную до первого использования. Нельзя присвоить значение имени, о котором компилятор ещё ничего не знает:

package main

import "fmt"

func main() {
    count = 5 // ✗
    fmt.Println(count)
}

undefined: count

Компилятор не создаёт переменную сам при первом присваивании. Сначала вы её объявляете: называете имя и тип значения, которое она будет хранить. Тип — это форма коробки: в коробку для целых чисел не положишь текст.

Три формы объявления

В Go переменную можно объявить тремя способами:

var a int = 1
var b = 2
c := 3
fmt.Println(a, b, c) // 1 2 3

Все три переменные целые, и fmt.Println печатает 1 2 3. Давайте разберём каждую форму отдельно.

Полная форма: var a int = 1

Строка читается слева направо:

• var — ключевое слово: «объявляю переменную»;
• a — имя переменной;
• int — её тип;
• = 1 — начальное значение.

Полную форму пишут, когда тип не должен следовать из значения. Например, var price float64 = 3 создаёт дробную переменную из целого числа. Без float64 компилятор выбрал бы для price тип int.

var без типа: var b = 2

Здесь тип не указан. Компилятор смотрит на значение 2 и сам выбирает для b тип int.

Эта форма короче полной и работает везде: и внутри функций, и вне их. Переменные, объявленные над func main, обычно пишут именно так.

Короткое объявление: c := 3

Оператор := — это короткое объявление. Он объявляет переменную и сразу задаёт ей значение. Тип он берёт из значения, как и var без типа.

Внутри функций это самая частая форма. Но у неё есть ограничение:

• := работает только внутри функции;
• строка x := 1 над func main не скомпилируется: syntax error: non-declaration statement outside function body;
• вне функций переменные объявляют только через var.

Имена переменных

Имя переменной начинается с буквы и состоит из букв и цифр. Составные имена в Go пишут слитно, начиная каждое следующее слово с заглавной буквы: itemCount, maxSpeed.

Присваивание

Оператор = меняет значение переменной, которая уже объявлена. Через := можно объявить несколько переменных сразу:

x, y := 1, 2
x = x + 10
fmt.Println(x, y) // 11 2

Разберём по строкам:

1. x, y := 1, 2 создаёт две переменные: x получает 1, а y — 2.
2. x = x + 10 читает старое значение x, прибавляет к нему 10 и записывает результат обратно в x.
3. fmt.Println(x, y) печатает 11 2: в коробке x теперь лежит 11, а y никто не трогал.

Здесь аналогия с коробкой неточна. Если вынуть вещь из настоящей коробки, коробка опустеет. А прочитать переменную — значит посмотреть на значение, а не забрать его: после fmt.Println(x) в x лежит то же число.

Константы

Ключевое слово const объявляет константу. Её значение известно уже при компиляции и потом не меняется — как коробка, которую запечатали ещё до запуска программы.

• Константу const limit = 10 можно читать, но присвоить ей новое значение нельзя.
• Константы, как и переменные через var, разрешены и внутри функций, и вне их.

На собеседовании часто спрашивают, чем отличаются var, const и :=. Ответ собирается из этого урока:

• var объявляет переменную где угодно — внутри функции и вне её;
• := объявляет переменную только внутри функции;
• const объявляет значение, известное при компиляции, и изменить его нельзя.

Частая ошибка

Оператор := написали для переменной, которая уже объявлена:

x := 1
x := 2 // ✗
fmt.Println(x)

no new variables on left side of :=

:= всегда объявляет хотя бы одну новую переменную, а x здесь уже есть. Чтобы изменить значение, нужен оператор =: x = 2.

Главное

• var объявляет переменную и внутри функций, и вне их, а := — только внутри функции.
• = меняет значение уже объявленной переменной, а := всегда создаёт хотя бы одну новую.
• const объявляет значение, известное при компиляции; присвоить ему новое нельзя.