Risposta.

Storia della domanda:

Le costanti in Go sono una parte integrante del linguaggio. Per costanti raggruppate con numerazione automatica si utilizza l'identificatore iota, introdotto sin dalle prime versioni di Go, per semplificare la dichiarazione di valori logicamente correlati.

Problema:

Molti sviluppatori commettono errori nell'uso di iota, fraintendendo come e dove si incrementa e come si applica in schemi di dichiarazione complessi. Questo porta a valori errati anche per strutture simili a enum semplici.

Soluzione:

iota consente di dichiarare costanti sequenziali e di raccogliere comodamente flag bit. Inizia da zero in ogni nuovo gruppo di costanti. Ogni nuovo blocco const o nuova riga nel blocco incrementa il valore di iota.

Esempio di codice:

// Esempio di maschera di flag e enum con iota
const (
    _ = iota // salto dello zero
    FlagRead // 1
    FlagWrite // 2
    FlagExecute // 3
)

const (
    ( // flag bit
        FlagA = 1 << iota // 1 << 0 = 1
        FlagB             // 1 << 1 = 2
        FlagC             // 1 << 2 = 4
    )
)

Caratteristiche chiave:

iota viene azzerato a zero nel blocco, riparte da zero con ogni gruppo di const.
È possibile impostare valori combinati e bit tramite iota.
Quando si salta una riga, l'espressione viene duplicata automaticamente e iota viene incrementato.

Domande insidiose.

Può iota aumentare al di fuori del blocco const o quando si dichiara una costante non in un gruppo?

No, iota funziona solo all'interno di un gruppo const. In caso di dichiarazione singola, il valore è sempre 0.

const A = iota // 0
const B = iota // 0 (nuovo blocco)

Cosa succede se nel gruppo non tutti i valori utilizzano iota?

Solo quelli dove è esplicitamente indicato otterranno un nuovo valore, gli altri otterranno l'espressione della riga precedente.

const (
    A = iota // 0
    B        // 1
    C = 10   // 10
    D        // 10 (non iota, ma ripetizione dell'espressione di C)
)

Come dichiarare maschere bit tramite iota?

Le maschere bit vengono realizzate tramite uno spostamento: 1 << iota.

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

Errori tipici e anti-pattern

Dimenticare di azzerare iota tra i gruppi const.
Uso di iota per costanti senza numerazione automatica, compromettendo la leggibilità.
Miscelazione errata di valori normali e valori tramite iota.

Esempio dalla vita reale

Caso negativo

Un ingegnere dichiara flag bit in diversi gruppi, credendo che iota continui a contare:

const (
   FlagA = 1 << iota // 1
   FlagB             // 2
)
const (
   FlagC = 1 << iota // 1 – e non 3 come previsto!
)

Pro:

Facilità di dichiarazione

Contro:

I flag si sovrappongono nei valori, causando bug nella combinazione bitwise

Caso positivo

Tutte le costanti collegate vengono raggruppate in un unico gruppo:

const (
    FlagA = 1 << iota
    FlagB
    FlagC
)