Réponse.

Contexte :

Les constantes en Go font partie intégrante du langage. Pour les constantes groupées avec numérotation automatique, l'identificateur iota est utilisé, introduit dès les premières versions de Go, pour simplifier la déclaration de valeurs logiquement liées.

Problème :

De nombreux développeurs se trompent lors de l'utilisation de iota, ne comprenant pas comment et où il s'incrémente, et comment il est appliqué dans des modèles de déclaration complexes. Cela entraîne des valeurs incorrectes même pour des structures semblables à des énumérations simples.

Solution :

Le iota permet de déclarer des constantes séquentielles et de rassembler des drapeaux binaires de manière pratique. Il commence à zéro dans chaque nouveau groupe de constantes. Chaque nouveau bloc const ou nouvelle ligne dans le bloc augmente la valeur de iota.

Exemple de code :

// Exemple de masque de drapeau et d'énumération avec iota
const (
    _ = iota // ignorer zéro
    FlagRead // 1
    FlagWrite // 2
    FlagExecute // 3
)

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

Caractéristiques clés :

iota est réinitialisé à zéro dans le bloc, recommençant à chaque groupe const.
Il est possible de définir des valeurs combinées et binaires via iota.
Lorsqu'une ligne est ignorée, l'expression est dupliquée automatiquement et iota s'incrémente.

Questions pièges.

iota peut-il s'incrémenter en dehors d'un bloc const ou lors de la déclaration d'une constante hors d'un groupe ?

Non, iota fonctionne uniquement à l'intérieur d'un groupe const. Lors d'une déclaration unique, la valeur est toujours 0.

const A = iota // 0
const B = iota // 0 (nouveau bloc)

Que se passe-t-il si tous les valeurs dans le groupe n'utilisent pas iota ?

Seules celles où cela est explicitement indiqué recevront une nouvelle valeur, les autres obtiendront l'expression de la ligne précédente.

const (
    A = iota // 0
    B        // 1
    C = 10   // 10
    D        // 10 (pas de iota, mais répétition de l'expression de C)
)

Comment déclarer des masques binaires avec iota ?

Les masques binaires sont réalisés par décalage : 1 << iota.

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

Erreurs typiques et anti-modèles

Oublier la réinitialisation de iota entre les groupes const.
Utilisation de iota pour des constantes sans numérotation automatique, ce qui nuit à la lisibilité.
Mauvaise combinaison de valeurs normales et de valeurs via iota.

Exemple de la vie réelle

Cas négatif

Un ingénieur déclare des drapeaux binaires dans différents groupes, pensant que iota continuera à compter :

const (
   FlagA = 1 << iota // 1
   FlagB             // 2
)
const (
   FlagC = 1 << iota // 1 – pas 3 comme prévu !
)

Avantages :

Simplicité de déclaration

Inconvénients :

Les drapeaux se chevauchent par valeur, des bugs surviennent lors de l'union par bits.

Cas positif

Toutes les constantes associées sont regroupées dans un seul groupe :

const (
    FlagA = 1 << iota
    FlagB
    FlagC
)