`iota` în Go

Contor folosit în blocurile const: pornește de la 0 și crește cu 1 la fiecare rând; ideal pentru enumerări.

Sintaxă

const (
    A = iota   // 0
    B          // 1
    C          // 2
)

Ce face `iota`

iota este o constantă specială care are valoarea 0 pe primul rând al unui bloc const ( ... ) și crește cu 1 pe fiecare rând următor. Dacă un rând nu are expresie, repetă expresia rândului de deasupra, cu noul iota. Așa se scriu enumerările în Go.

De obicei se definește un tip propriu (type Zi int) și constantele de acel tip, plus o metodă String() pentru afișare. Cu expresii se pot obține și alte șiruri: 1 << iota dă 1, 2, 4, 8 (indicatori pe biți), iota * 10 dă 0, 10, 20. Cu _ sari peste o valoare.

Exemple

Exemplul 1: Enumerare cu tip propriu și String()

fmt.Println folosește automat metoda String().

package main

import "fmt"

type Stare int

const (
    InAsteptare Stare = iota // 0
    Trimisa                  // 1
    Livrata                  // 2
    Anulata                  // 3
)

func (s Stare) String() string {
    return [...]string{"în așteptare", "trimisă", "livrată", "anulată"}[s]
}

func main() {
    comanda := Trimisa
    fmt.Println("starea comenzii:", comanda, "valoare:", int(comanda))
    comanda = Livrata
    fmt.Println("acum:", comanda)
}

Rezultat

starea comenzii: trimisă valoare: 1
acum: livrată

Exemplul 2: Indicatori pe biți și valori sărite

1 << iota dă puteri ale lui 2; permisiunile se combină cu | și se verifică cu &.

package main

import "fmt"

const (
    Citire   = 1 << iota // 1
    Scriere              // 2
    Stergere             // 4
)

const (
    _  = iota             // sărim peste 0
    KB = 1 << (10 * iota) // 1024
    MB                    // 1048576
    GB                    // 1073741824
)

func main() {
    drepturi := Citire | Scriere
    fmt.Println("drepturi:", drepturi)
    fmt.Println("poate scrie:", drepturi&Scriere != 0)
    fmt.Println("poate șterge:", drepturi&Stergere != 0)
    fmt.Println(KB, MB, GB)
}