Константы и iota в Go: частые ошибки новичков

Что нужно знать до начала

Все примеры проверены на Go 1.22. Поведение iota не менялось с Go 1.0, поэтому код будет работать на любой актуальной версии. Для запуска достаточно установленного Go и любого редактора — VS Code с расширением Go, GoLand или даже Go Playground в браузере.

Как работает iota: минимум теории

iota — счётчик внутри блока const. Он начинается с нуля и увеличивается на единицу для каждой новой строки блока, а не для каждого имени. Если строка содержит несколько констант через запятую — все они получат одно и то же значение iota. Вне блока const идентификатор iota не существует.

Выражение из предыдущей строки неявно повторяется для следующих строк, если новое выражение не задано. Именно на этих двух правилах — «счётчик по строкам» и «неявное повторение» — спотыкается большинство новичков.

Ошибка 1. Нулевое значение совпадает с zero value типа

Самая частая ловушка. Вы объявляете тип-перечисление, и первая константа получает значение 0 — то же самое, что zero value для любого int-подобного типа. В итоге неинициализированная переменная неотличима от первого элемента перечисления.

package main

import "fmt"

type Role int

const (
    Admin Role = iota // 0
    Editor             // 1
    Viewer             // 2
)

func main() {
    var r Role // zero value — 0, то есть Admin
    fmt.Println(r == Admin) // true, хотя роль не назначали
}

Переменная r не была явно задана, но программа считает её Admin. В системе авторизации это означает случайное повышение привилегий.

Как исправить

Зарезервируйте нулевое значение под «неизвестное» или «невалидное» состояние:

const (
    RoleUnknown Role = iota // 0 — явно невалидное
    Admin                   // 1
    Editor                  // 2
    Viewer                  // 3
)

Теперь неинициализированная переменная — RoleUnknown, и вы поймаете её в валидации до того, как она попадёт в бизнес-логику.

Ошибка 2. Вставка строки в середину блока

Вы добавляете новую роль между существующими — и все значения после неё сдвигаются. Если константы сохраняются в базу данных, в файлы или передаются по сети, старые записи начинают означать не то, что раньше.

// Было:
const (
    RoleUnknown Role = iota
    Admin   // 1
    Editor  // 2
    Viewer  // 3
)

// Стало — добавили Moderator между Admin и Editor:
const (
    RoleUnknown Role = iota
    Admin      // 1
    Moderator  // 2 — заняло бывшее значение Editor
    Editor     // 3 — сдвинулось
    Viewer     // 4 — сдвинулось
)

Всё, что было сохранено как 2, теперь читается как Moderator вместо Editor.

Как исправить

Два варианта:

• Добавляйте новые константы только в конец блока, перед служебной «стражей» (sentinel).
• Если порядок может меняться, откажитесь от iota и задайте значения явно:

const (
    RoleUnknown Role = 0
    Admin       Role = 1
    Editor      Role = 2
    Viewer      Role = 3
    Moderator   Role = 4 // новое значение не ломает старые
)

Правило: если значение константы покидает границы процесса — уходит в базу, в JSON, в gRPC — привязывайте его явно, а не через iota. Удобство автонумерации не стоит сломанной миграции.

Ошибка 3. Пустая строка (blank identifier) сбивает счёт

Иногда разработчик хочет пропустить значение и пишет _. Это работает — но только если вы помните, что iota считает строки, а не имена.

const (
    A = iota // 0
    _        // 1 — пропущено, но iota увеличилась
    B        // 2, а не 1
)

Ошибка здесь не в механике, а в ожиданиях: новичок думает, что B получит 1, потому что «мы пропустили одну». На деле _ — полноценная строка с точки зрения iota.

Чтобы получить конкретное значение с пропуском, используйте арифметику:

const (
    Read    = 1 << iota // 1
    Write               // 2
    Execute             // 4
)

Здесь пропусков нет, но битовый сдвиг сам создаёт «разрывы» в числовых значениях — и это осознанное решение, а не побочный эффект.

Ошибка 4. iota в нескольких блоках const

iota сбрасывается в ноль в каждом новом блоке const. Два перечисления в одном файле получат пересекающиеся числовые значения.

type Color int
type Size int

const (
    Red   Color = iota // 0
    Green              // 1
    Blue               // 2
)

const (
    Small  Size = iota // 0 — снова ноль
    Medium             // 1
    Large              // 2
)

Сами по себе совпадения не страшны: Color и Size — разные типы, компилятор не даст присвоить один другому. Проблема всплывает, когда значения попадают в нетипизированный контекст — interface{}, JSON, логи, SQL. Там 0 — это 0, и отличить Red от Small невозможно.

Как исправить

Разнесите диапазоны вручную или используйте строковые константы, если значения уходят наружу:

const (
    Red   Color = iota + 100 // 100
    Green                     // 101
    Blue                      // 102
)

const (
    Small  Size = iota + 200 // 200
    Medium                    // 201
    Large                     // 202
)

Ошибка 5. Нет метода String() — отладка вслепую

Без String() ваше перечисление в логах и fmt.Println выглядит как голое число. При пяти константах это терпимо, при двадцати — нечитаемо.

func (r Role) String() string {
    switch r {
    case RoleUnknown:
        return "unknown"
    case Admin:
        return "admin"
    case Editor:
        return "editor"
    case Viewer:
        return "viewer"
    default:
        return fmt.Sprintf("Role(%d)", int(r))
    }
}

Ветка default критически важна: если кто-то приведёт произвольный int к типу Role, вы получите осмысленный вывод вместо паники или пустой строки.

Для больших перечислений удобнее генерировать String() утилитой stringer из пакета golang.org/x/tools:

//go:generate stringer -type=Role

Команда go generate ./... создаст файл role_string.go с готовой реализацией.

Сводная таблица ошибок

Сноска. iota — встроенный идентификатор Go, представляющий целочисленный счётчик, который автоматически увеличивается на 1 для каждой строки внутри блока const. За пределами const не используется и аналогов в большинстве других языков не имеет.

Что делать дальше

Проверьте существующие перечисления в проекте по чек-листу:

1. Есть ли Unknown / Invalid с нулевым значением?
2. Сохраняются ли значения за пределами процесса? Если да — заданы ли они явно, а не через iota?
3. Реализован ли String() у каждого enum-типа?
4. Есть ли sentinel-константа вроде _roleEnd в конце блока для валидации диапазона?

Если хотите углубиться — изучите пакет golang.org/x/tools/cmd/stringer и директиву //go:generate. Это избавит от ручного поддержания String() при каждом изменении списка констант. Тема генерации кода в Go — отдельный разговор, но начать стоит именно со stringer: он решает самую частую задачу с минимальной настройкой.