Antwort.

Geschichte der Frage:

Konstanten in Go sind ein unverzichtbarer Teil der Sprache. Für gruppierte Konstanten mit automatischer Nummerierung wird der Bezeichner iota verwendet, der bereits in den frühesten Versionen von Go eingeführt wurde, um die Deklaration logisch verbundener Werte zu vereinfachen.

Problem:

Viele Entwickler machen Fehler bei der Arbeit mit iota, indem sie missverstehen, wie und wo er erhöht wird und wie er bei komplexen Deklarationsmustern angewendet wird. Dies führt zu falschen Werten selbst für einfache enum-ähnliche Strukturen.

Lösung:

iota ermöglicht es, aufeinanderfolgende Konstanten zu deklarieren und Bit-Flags bequem zu sammeln. Er beginnt bei null in jeder neuen Konstantengruppe. Jeder neue const-Block oder neue Zeile im Block erhöht den Wert von iota.

Beispielcode:

// Beispiel für eine Flag-Maske und enum mit iota
const (
    _ = iota // überspringe null
    FlagRead // 1
    FlagWrite // 2
    FlagExecute // 3
)

const (
    ( // Bit-Flags
        FlagA = 1 << iota // 1 << 0 = 1
        FlagB             // 1 << 1 = 2
        FlagC             // 1 << 2 = 4
    )
)

Wichtige Eigenschaften:

iota wird im Block auf null zurückgesetzt und beginnt bei jeder Gruppe von const von vorne.
Kombinierte und bitweise Werte können durch iota festgelegt werden.
Wenn eine Zeile übersprungen wird, wird der Ausdruck automatisch dupliziert, und iota wird erhöht.

Fangfragen.

Kann iota außerhalb des const-Blocks oder bei der Deklaration einer Konstante nicht in der Gruppe erhöht werden?

Nein, iota funktioniert nur innerhalb einer Gruppe von const. Bei einer einzelnen Deklaration beträgt der Wert immer 0.

const A = iota // 0
const B = iota // 0 (neuer Block)

Was passiert, wenn nicht alle Werte in der Gruppe iota verwenden?

Nur die, bei denen dies ausdrücklich angegeben ist, erhalten einen neuen Wert, die anderen erhalten den Ausdruck der vorherigen Zeile.

const (
    A = iota // 0
    B        // 1
    C = 10   // 10
    D        // 10 (nicht iota, sondern Wiederholung des Ausdrucks aus C)
)

Wie werden Bitmasken mit iota deklariert?

Bitmasken werden durch Verschiebung realisiert: 1 << iota.

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

Typische Fehler und Anti-Pattern

Vergessen, iota zwischen den Gruppen von const zurückzusetzen.
Verwendung von iota für Konstanten ohne automatische Nummerierung, was die Lesbarkeit verschlechtert.
Falsches Mischen von normalen Werten und Werten durch iota.

Beispiel aus dem Leben

Negativer Fall

Ein Ingenieur deklariert Bit-Flags in verschiedenen Gruppen und glaubt, dass iota den Zähler fortsetzt:

const (
   FlagA = 1 << iota // 1
   FlagB             // 2
)
const (
   FlagC = 1 << iota // 1 – und nicht 3 wie erwartet!
)

Vorteile:

Einfachheit der Deklaration

Nachteile:

Flags überschneiden sich im Wert, es treten Bugs beim bitweisen Kombinieren auf.

Positiver Fall

Alle verwandten Konstanten werden in einer Gruppe zusammengefasst:

const (
    FlagA = 1 << iota
    FlagB
    FlagC
)