Antwoord.

Achtergrond van de vraag:

Constanten in Go zijn een onmiskenbaar onderdeel van de taal. Voor gegroepeerde constanten met automatische nummering wordt de identifier iota gebruikt, die al in de eerste versies van Go is geïntroduceerd om de declaratie van logisch gerelateerde waarden te vereenvoudigen.

Probleem:

Veel ontwikkelaars maken fouten bij het werken met iota door verkeerd te begrijpen hoe en waar het wordt verhoogd, en hoe het wordt toegepast bij complexe declaratiepatronen. Dit leidt tot onjuiste waarden, zelfs voor eenvoudige enum-achtige structuren.

Oplossing:

iota maakt het mogelijk om opeenvolgende constanten te declareren en handig bitvlaggen te verzamelen. Het begint bij nul in elke nieuwe constante groep. Elke nieuwe const-blok of nieuwe regel in een blok verhoogt de waarde van iota.

Voorbeeldcode:

// Voorbeeld van een vlaggenmasker en enum met iota
const (
    _ = iota // overslaan van nul
    FlagRead // 1
    FlagWrite // 2
    FlagExecute // 3
)

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

Belangrijke kenmerken:

iota wordt gereset naar nul in een blok en begint opnieuw met elke groep const.
Gecombineerde en bitwaarden kunnen via iota worden ingesteld.
Bij het overslaan van een regel wordt de expressie automatisch gedupliceerd en iota verhoogd.

Misleidende vragen.

Kan iota buiten een const-blok of bij het declareren van een constante niet in de groep toenemen?

Nee, iota werkt alleen binnen een const-groep. Bij een enkele declaratie is de waarde altijd 0.

const A = iota // 0
const B = iota // 0 (nieuwe blok)

Wat gebeurt er als niet alle waarden in de groep iota gebruiken?

Alleen die waar dit expliciet is aangegeven, krijgen een nieuwe waarde; de anderen ontvangen de expressie van de vorige regel.

const (
    A = iota // 0
    B        // 1
    C = 10   // 10
    D        // 10 (geen iota, maar herhaling van de expressie uit C)
)

Hoe declareer je bitmaskers met behulp van iota?

Bitmaskers worden geïmplementeerd door middel van verschuiving: 1 << iota.

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

Typefouten en anti-patronen

Vergeten om iota te resetten tussen const-groepen.
Gebruik van iota voor constanten zonder automatische nummering, wat de leesbaarheid vermindert.
Verkeerd mengen van gewone waarden en waarden via iota.

Voorbeeld uit het leven

Negatieve casus

Een ingenieur declareert bitvlaggen in verschillende groepen, in de veronderstelling dat iota de teller zal voortzetten:

const (
   FlagA = 1 << iota // 1
   FlagB             // 2
)
const (
   FlagC = 1 << iota // 1 – en niet 3 zoals verwacht!
)

Voordelen:

Eenvoud van declaratie

Nadelen:

Vlaggen overlappen in waarde, waardoor bugs ontstaan bij bitwise combinatie.

Positieve casus

Alle gerelateerde constanten worden samengevoegd in één groep:

const (
    FlagA = 1 << iota
    FlagB
    FlagC
)