Ответ.

История вопроса:

Константы в Go – неотъемлемая часть языка. Для группированных констант с автонумерацией используется идентификатор iota, представленный еще в самых первых версиях Go, чтобы упростить объявление логически связанных значений.

Проблема:

Многие разработчики ошибаются при работе с iota, неверно понимая, как и где он увеличивается, и как применяется при сложных паттернах объявления. Это приводит к неверным значениям даже для простых enum-подобных структур.

Решение:

iota позволяет объявлять последовательные константы и удобно собирать битовые флаги. Он начинается с нуля в каждой новой константной группе. Каждый новый const-блок или новая строка в блоке увеличивает значение iota.

Пример кода:

// Пример флаговой маски и enum с iota
const (
    _ = iota // пропуск нуля
    FlagRead // 1
    FlagWrite // 2
    FlagExecute // 3
)

const (
    ( // битовые флаги
        FlagA = 1 << iota // 1 << 0 = 1
        FlagB             // 1 << 1 = 2
        FlagC             // 1 << 2 = 4
    )
)

Ключевые особенности:

iota сбрасывается к нулю в блоке, начинается сначала с каждой группы const.
Можно задавать комбинированные и битовые значения через iota.
При пропуске строки выражение дублируется автоматически, а iota увеличивается.

Вопросы с подвохом.

Может ли iota увеличиться вне блока const или при объявлении константы не в группе?

Нет, iota работает только внутри группы const. При одиночном объявлении всегда значение 0.

const A = iota // 0
const B = iota // 0 (новый блок)

Что произойдет, если в группе не все значения используют iota?

Только те, где явно указано – получат новое значение, остальные получают выражение предыдущей строки.

const (
    A = iota // 0
    B        // 1
    C = 10   // 10
    D        // 10 (не iota, а повторение выражения из C)
)

Как объявлять битовые маски с помощью iota?

Битовые маски реализуют через сдвиг: 1 << iota.

const (
    F1 = 1 << iota // 1
    F2             // 2
    F3             // 4
)

Типовые ошибки и анти-паттерны

Забывать сброс iota между группами const.
Использование iota для констант без автонумерации, что ухудшает читаемость.
Неправильное смешивание обычных значений и значений через iota.

Пример из жизни

Негативный кейс

Инженер объявляет битовые флаги в разных группах, считая, что iota продолжит счетчик:

const (
   FlagA = 1 << iota // 1
   FlagB             // 2
)
const (
   FlagC = 1 << iota // 1 – а не 3 как ожидалось!
)

Плюсы:

Простота объявления

Минусы:

Флаги пересекаются по значению, возникают баги при побитовом объединении

Позитивный кейс

Все связанные константы объединяются в одну группу:

const (
    FlagA = 1 << iota
    FlagB
    FlagC
)