Costanti e iota

Le costanti sono valori immutabili noti a compile-time. In Go si dichiarano con const e possono essere tipate o non tipate. Quelle non tipate hanno un superpotere: si adattano al tipo richiesto dal contesto, evitando di dover scrivere conversioni esplicite.

Sintassi base

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

MaxRetry è tipata (int): puoi assegnarla solo a un int. PI e Name sono non tipate: si comportano come "letterali" e si adattano al contesto.

const PI = 3.14

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

Blocchi const

Puoi raggruppare più costanti in un blocco:

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

iota: il contatore delle enumerazioni

Dentro a un blocco const, l'identificatore speciale iota parte da 0 e si incrementa di 1 a ogni riga. È l'idioma per fare enumerazioni:

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

Le righe successive ereditano l'espressione se non ne forniscono una. Ecco perché basta scrivere Tuesday senza ripetere = iota.

Pattern con espressioni

iota può comparire dentro a espressioni arbitrarie:

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

Saltare un valore

Se non vuoi assegnare un valore a una riga (perché vuoi che iota si incrementi comunque), usa il blank identifier _:

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

Prova tu

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

Recap

• const per valori immutabili noti a compile-time.
• Costanti non tipate si adattano al contesto: nessuna conversione necessaria.
• Blocchi const ( ... ) raggruppano valori correlati.
• iota parte da 0 in ogni blocco e si incrementa di riga in riga.
• Pattern: enum (= iota), bitmask (= 1 << iota), unità (= 1 << (10*iota)).