Respuesta.

Historia de la cuestión:

Las constantes en Go son parte integral del lenguaje. Para constantes agrupadas con numeración automática se utiliza el identificador iota, presentado desde las primeras versiones de Go, para simplificar la declaración de valores lógicamente relacionados.

Problema:

Muchos desarrolladores cometen errores al trabajar con iota, entendiendo incorrectamente cómo y dónde se incrementa, y cómo se aplica en patrones complejos de declaración. Esto lleva a valores incorrectos incluso para estructuras simples similares a enumeraciones.

Solución:

iota permite declarar constantes secuenciales y recopilar fácilmente banderas de bits. Comienza en cero en cada nuevo grupo de constantes. Cada nuevo bloque const o nueva línea en el bloque incrementa el valor de iota.

Ejemplo de código:

// Ejemplo de máscara de bandera y enum con iota
const (
    _ = iota // omitir cero
    FlagRead // 1
    FlagWrite // 2
    FlagExecute // 3
)

const (
    ( // banderas de bits
        FlagA = 1 << iota // 1 << 0 = 1
        FlagB             // 1 << 1 = 2
        FlagC             // 1 << 2 = 4
    )
)

Características clave:

iota se reinicia a cero dentro del bloque, comienza de nuevo en cada grupo const.
Se pueden establecer valores combinados y de bits a través de iota.
Al omitir una línea, la expresión se duplica automáticamente, y iota se incrementa.

Preguntas engañosas.

¿Puede iota incrementarse fuera del bloque const o al declarar una constante fuera de un grupo?

No, iota solo funciona dentro del grupo const. En una declaración única, siempre tiene el valor 0.

const A = iota // 0
const B = iota // 0 (nuevo bloque)

¿Qué sucederá si en el grupo no todos los valores utilizan iota?

Solo aquellos que están expresamente indicados obtendrán un nuevo valor, los restantes obtienen la expresión de la línea anterior.

const (
    A = iota // 0
    B        // 1
    C = 10   // 10
    D        // 10 (no iota, sino repetición de la expresión de C)
)

¿Cómo declarar máscaras de bits con iota?

Las máscaras de bits se implementan mediante desplazamiento: 1 << iota.

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

Errores comunes y antipatrón

Olvidar reiniciar iota entre grupos const.
Usar iota para constantes sin numeración automática, lo que empeora la legibilidad.
Mezclar incorrectamente valores normales y valores a través de iota.

Ejemplo de la vida real

Caso negativo

Un ingeniero declara banderas de bits en diferentes grupos, pensando que iota continuará el contador:

const (
   FlagA = 1 << iota // 1
   FlagB             // 2
)
const (
   FlagC = 1 << iota // 1 – ¡y no 3 como se esperaba!
)

Ventajas:

Facilidad de declaración

Desventajas:

Las banderas se superponen por valor, surgen errores al combinar bits

Caso positivo

Todas las constantes relacionadas se agrupan en un solo grupo:

const (
    FlagA = 1 << iota
    FlagB
    FlagC
)