Модуль 5 ⏱ ~23 мин чтения 📐 1 Mermaid диаграмм

5. Переменные, константы и вывод типа

В динамических языках (Python, JavaScript, PHP) переменные — это всего лишь гибкие символические ярлыки для значений в куче, способные в любой момент исполнения изменить свой тип. В классических системных языках вроде C и C++ переменная строго привязана к машинному типу и физическому адресу памяти, однако забота о безопасной инициализации ячейки целиком перекладывается на плечи программиста.

Создатели Go заняли бескомпромиссную позицию прагматичной безопасности:

  • Язык строго и статически типизирован;
  • Неявных преобразований между числовыми типами (implicit type casting) нет: int не превратится в int64 или float64 сам (присваивание нетипизированных констант и значений интерфейсам подчиняется правилам присваиваемости — о них ниже);
  • Неинициализированной памяти (с «мусором», оставшимся от прежних вычислений программы) в Go не существует в принципе.

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

Два стула инициализации: var и :=

В Go предусмотрено два базовых синтаксических способа объявления переменных. Четкое понимание границы между ними отличает зрелый идиоматичный код от неуклюжей кальки с других языков.

1. Ключевое слово var

Оператор var применяется при явном указании типа, либо когда требуется зарезервировать память под переменную, оставив ее инициализацию на более поздний момент (в этом случае она гарантированно получит безопасное нулевое значение — Zero Value).

Go 
// Объявление на уровне пакета (глобальные переменные) допустимо ТОЛЬКО через var
var GlobalCounter int64 = 100

func process() {
    // Явное указание типа (полезно, если конкретный тип важен для контракта)
    var timeout time.Duration = 5 * time.Second

    // Объявление без явного присвоения: переменная attempt инициализируется нулем (0)
    var attempt int 
}

2. Краткое объявление (:=)

Синтаксическая конструкция := одновременно объявляет переменную и присваивает ей значение, делегируя вычисление точного типа компилятору (Type Inference). Данная форма доступна исключительно внутри тел функций.

Go 
func process() {
    timeout := 5 * time.Second // Компилятор самостоятельно выведет тип time.Duration
    count := 10                // По умолчанию целочисленный литерал выводится как int
}

Идиоматичный подход

  1. Используйте краткую форму := в 95% случаев для локальных переменных внутри функций.
  2. Используйте var, когда требуется объявить структуру или срез, готовый к работе со своим нулевым значением, без лишних аллокаций.
  3. Используйте var, если выводимый по умолчанию тип вам не подходит (например, если требуется конкретный размер int32, а запись count := 10 породит системный int).

Ловушка: Затенение переменных (Shadowing)

Краткая форма := таит в себе классический подводный камень, на котором регулярно спотыкаются разработчики — особенно при обработке ошибок.

Оператор := создает новые переменные в текущей локальной области видимости (scope). Но если в той же области одна из переменных слева уже объявлена (a, err := f(); b, err := g()), := присвоит ей значение, а не создаст новую — нужна лишь хотя бы одна новая переменная. Если же переменная с идентичным именем была объявлена во внешней области видимости, внешняя переменная не будет перезаписана — во вложенном блоке появится новая, и внешняя будет молча затенена (shadowed).

Go 
var globalErr error

func doSomething() {
    // ...
    if condition {
        // ЛОВУШКА!
        // Оператор := объявляет НОВУЮ локальную переменную globalErr внутри блока if!
        // Глобальная переменная globalErr в пакете остается равной nil.
        result, globalErr := operation()
        _ = result
        if globalErr != nil {
            return
        }
    }

    // Внимание: внешняя globalErr здесь по-прежнему равна nil!
}

Zero Values: Безопасность на уровне памяти

В C и C++ объявление переменной без явной инициализации (int x;) оставляет в ячейке памяти «мусор» — значения, оставшиеся в этой ячейке от прежних вызовов функций или освобождённых блоков памяти той же программы (страницы, которые выдаёт ядро ОС, всегда обнулены). Это исторический источник утечек данных, неопределённого поведения и трудноуловимых ошибок.

В Go неинициализированной памяти не существует в принципе. Любая переменная, выделенная в коде, гарантированно инициализируется своим детерминированным «нулевым значением» (Zero Value):

  • Числовые типы (int, int32, int64, float64) получают 0;
  • Логический тип (bool) получает false;
  • Строковый тип (string) получает пустую строку "" (заголовок с длиной 0 и нулевым указателем на байты);
  • Указатели, слайсы, мапы, каналы, интерфейсы и функции получают nil;
  • Структуры рекурсивно зануляются: каждое поле структуры получает соответствующий Zero Value.

Mechanical Sympathy: Как работает зануление

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

Переменные на стеке (там их оставляет Escape Analysis) зануляет код, который вставляет сам компилятор (на amd64 — широкими записями специально выделенного нулевого регистра X15). Память в куче чистит рантайм — специализированными платформенными ассемблерными процедурами вроде runtime.memclrNoHeapPointers, — если она не пришла от ОС уже нулевой.

На современных процессорах x86-64 и ARM64 функция runtime.memclrNoHeapPointers использует векторные SIMD-инструкции (расширения AVX/SSE или NEON), записывая нули широкими аппаратными блоками по 16, 32 или 64 байта за инструкцию. Таким образом, Go разменивает буквально доли наносекунды на абсолютную безопасность и предсказуемость исполнения.

Магия нетипизированных констант

Константы в Go, объявляемые через ключевое слово const, кардинально отличаются от доступных только для чтения переменных (read-only variables) в C++ или Java.

Главное отличие: в Go константы могут быть нетипизированными (untyped):

Go 
const a = 5         // Нетипизированная числовая константа (untyped int)
const b int32 = 5   // Строго типизированная константа типа int32

В чем разница под капотом?

Типизированная константа подчиняется жестким правилам статической типизации Go. Вы не можете сложить b (типа int32) с переменной типа int64 без явного приведения типов.

Нетипизированная константа живет исключительно в памяти компилятора на этапе сборки. В бинарном файле под нее не выделяется физический участок памяти до тех пор, пока константа не подставится в конкретное выражение. Компилятор Go представляет нетипизированные константы как абстрактные математические числа очень высокой точности: спецификация требует не менее 256 бит для целых, компилятор gc поддерживает больше, но не бесконечно (const huge = 1 << 600 уже даёт ошибку constant shift overflow).

flowchart TD
    C["const x = 5<br>(Нетипизированное идеальное число в AST)"] --> A["var i int32 = x"]
    C --> B["var f float64 = x"]
    A -->|"Компилятор: 5 влезает в int32"| CA["Сборка успешна: тип int32"]
    B -->|"Компилятор: 5 влезает в float64"| CB["Сборка успешна: тип float64"]

    C2["const y int64 = 5<br>(Строго типизированная константа)"] --> D["var z int32 = y"]
    D -->|"Компилятор: смешение int64 и int32!"| E["Compilation Error"]

    style C fill:#1e293b,stroke:#38bdf8,stroke-width:2px,color:#e2e8f0
    style C2 fill:#2d1515,stroke:#ef4444,stroke-width:2px,color:#fecaca
    style CA fill:#132e1b,stroke:#22c55e,stroke-width:2px,color:#bbf7d0
    style CB fill:#132e1b,stroke:#22c55e,stroke-width:2px,color:#bbf7d0
    style E fill:#2d1515,stroke:#ef4444,stroke-width:2px,color:#fecaca

Это свойство позволяет писать математические выражения без бесконечных ручных кастов вида int32(), float64():

Go 
const secondsInHour = 60 * 60 // Вычисляется компилятором при проверке типов!
var delay time.Duration = secondsInHour * time.Second // 1h0m0s; без * time.Second было бы 3.6µs

// Вычисления гигантских порядков (далеко за пределами int64):
const HugeNumber = 1 << 100 
const SmallNumber = HugeNumber >> 99
var result int = SmallNumber // result = 2, собирается без переполнений!

Iota: Элегантные перечисления

В Go сознательно не стали вводить тяжелое ключевое слово enum. Вместо этого перечисления реализуются через блоки констант и специальный идентификатор iota.

Генератор iota начинает отсчет с 0 и автоматически инкрементируется на 1 для каждой новой строки внутри блока const():

Go 
const (
    StatePending = iota // 0
    StateRunning        // 1
    StateFailed         // 2
)

В сочетании с побитовыми сдвигами iota превращается в идеальный инструмент создания битовых масок (bitmasks), повсеместно используемых в сетевых протоколах и системных флагах:

Go 
const (
    FlagRead  = 1 << iota // 1 (двоичное 001)
    FlagWrite             // 2 (двоичное 010)
    FlagExec              // 4 (двоичное 100)
)

Итог

  1. var vs :=: Используйте краткую форму := для локальных вычислений внутри функций. Применяйте ключевое слово var для переменных уровня пакета и в тех случаях, когда вам нужно чистое нулевое значение (Zero Value).
  2. Опасность затенения (Shadowing): Будьте предельно внимательны с оператором := во вложенных блоках if и for. Затенение переменной приводит к тихой потере ошибок и состояний.
  3. Аппаратное зануление памяти: В Go не бывает случайного «мусора» в памяти. Стек зануляет код, вставленный компилятором, а кучу — процедуры рантайма вроде runtime.memclrNoHeapPointers, использующие векторные инструкции SIMD.
  4. Нетипизированные константы: Уникальный механизм времени компиляции с очень высокой (не менее 256 бит) математической точностью, избавляющий от рутинного приведения числовых типов.

Освоив механику объявления переменных и обнуления памяти, мы готовы подробно изучить саму систему встроенных типов. В следующей статье 6. Базовые типы данных. int, float, bool, string мы разберем машинную разрядность целых чисел, тонкости чисел с плавающей точкой и внутреннее устройство неизменяемых строк.