Constantes e iota

Las constantes son valores inmutables conocidos en el momento de la compilación. En Go están declarado con const y se puede escribir o sin escribir. Los no tipificados tienen un superpoder: se adaptan al tipo que requiere el contexto, evitándote de tener que escribir conversiones explícitas.

Sintaxis básica

const PI = 3.14
const MaxRetry int = 5
const Name = "eLearner"

Se escribe MaxRetry (int): solo puedes asignarlo a un int. PI y Name están sin tipo: se comportan como "literales" y se adaptan a el contexto.

const PI = 3.14

var f float32 = PI  // ok: PI è non tipata, diventa float32
var d float64 = PI  // ok

bloques const

Puedes agrupar varias constantes en un bloque:

const (
    StateInitial = "INIT"
    StateReady   = "READY"
    StateError   = "ERROR"
)

iota: el contador de enumeración

Dentro de un bloque const, el identificador especial iota comienza en 0 y aumenta en 1 en cada línea. Es el modismo para hacer enumeraciones:

const (
    Monday = iota // 0
    Tuesday       // 1
    Wednesday     // 2
    Thursday      // 3
    Friday        // 4
)

Las líneas siguientes heredan la expresión si no proporcionan una. Por eso es suficiente escribir Tuesday sin repetir = iota.

Patrones con expresiones.

iota puede aparecer dentro de expresiones arbitrarias:

const (
    KB = 1 << (10 * (iota + 1)) // 1 << 10 = 1024
    MB                          // 1 << 20
    GB                          // 1 << 30
    TB                          // 1 << 40
)

Saltar un valor

Si no desea asignar un valor a una línea (porque desea que iota incrementar de todos modos), use el identificador en blanco _:

const (
    _  = iota // scarta 0
    KB        // 1
    MB        // 2
)

Tu turno

const (
    A = iota * 2
    B
    C
)
fmt.Println(A, B, C)

Resumen

• const para valores inmutables conocidos en tiempo de compilación.
• Las constantes sin tipo se adaptan al contexto: no se necesita conversión.
• const ( ... ) bloquea valores relacionados con el grupo.
• iota comienza en 0 en cada bloque y aumenta línea por línea.
• Patrones: enumeración (= iota), máscara de bits (= 1 << iota), unidades (= 1 << (10*iota)).