Go => Iota

introduzione

Iota fornisce un modo per dichiarare le costanti numeriche da un valore iniziale che cresce monotonicamente. Iota può essere utilizzato per dichiarare maschere di bit che vengono spesso utilizzate nella programmazione di sistemi e reti e altri elenchi di costanti con valori correlati.

Osservazioni

L'identificatore iota viene utilizzato per assegnare valori agli elenchi di costanti. Quando iota viene utilizzato in un elenco, inizia con un valore pari a zero e aumenta di uno per ogni valore nell'elenco di costanti e viene reimpostato su ogni parola chiave const . A differenza delle enumerazioni di altre lingue, iota può essere utilizzato nelle espressioni (ad esempio iota + 1 ) che consente una maggiore flessibilità.

Semplice utilizzo di iota

Per creare un elenco di costanti - assegnare un valore iota a ciascun elemento:

const (
  a = iota // a = 0
  b = iota // b = 1
  c = iota // c = 2
)

Per creare un elenco di costanti in modo abbreviato, assegna il valore iota al primo elemento:

const (
  a = iota // a = 0
  b        // b = 1
  c        // c = 2
)

Usare iota in un'espressione

iota può essere utilizzato nelle espressioni, quindi può anche essere utilizzato per assegnare valori diversi dai semplici numeri interi incrementali a partire da zero. Per creare costanti per unità SI, utilizzare questo esempio di Effective Go :

type ByteSize float64

const (
    _           = iota // ignore first value by assigning to blank identifier
    KB ByteSize = 1 << (10 * iota)
    MB
    GB
    TB
    PB
    EB
    ZB
    YB
)

Saltare valori

Il valore di iota viene comunque incrementato per ogni voce in un elenco costante anche se iota non viene utilizzato:

const ( // iota is reset to 0
    a = 1 << iota  // a == 1
    b = 1 << iota  // b == 2
    c = 3          // c == 3  (iota is not used but still incremented)
    d = 1 << iota  // d == 8
)

verrà anche incrementato anche se non viene creata alcuna costante, il che significa che l'identificatore vuoto può essere utilizzato per saltare interamente i valori:

const (
  a = iota // a = 0
  _        // iota is incremented
  b        // b = 2
)

Il primo blocco di codice è stato preso da Go Spec (CC-BY 3.0).

Uso di iota in un elenco di espressioni

Poiché iota viene incrementato dopo ogni ConstSpec , i valori all'interno dello stesso elenco di espressioni avranno lo stesso valore per lo iota :

const (
    bit0, mask0 = 1 << iota, 1<<iota - 1  // bit0 == 1, mask0 == 0
    bit1, mask1                           // bit1 == 2, mask1 == 1
    _, _                                  // skips iota == 2
    bit3, mask3                           // bit3 == 8, mask3 == 7
)

Questo esempio è stato preso da Go Spec (CC-BY 3.0).

Uso di iota in una maschera di bit

Iota può essere molto utile quando si crea una maschera di bit. Ad esempio, per rappresentare lo stato di una connessione di rete che può essere sicura, autenticata e / o pronta, potremmo creare una maschera di bit simile alla seguente:

const (
    Secure = 1 << iota // 0b001
    Authn              // 0b010
    Ready              // 0b100
)

ConnState := Secure|Authn // 0b011: Connection is secure and authenticated, but not yet Ready

Uso di iota in const

Questa è un'enumerazione per la creazione di cost. Il compilatore inizia iota da 0 e incrementa di uno per ogni costante successiva. Il valore è determinato in fase di compilazione anziché in fase di esecuzione. Per questo motivo non possiamo applicare iota alle espressioni che vengono valutate in fase di esecuzione.

Programma per utilizzare iota in const

package main

import "fmt"

const (
    Low = 5 * iota
    Medium
    High
)

func main() {
    // Use our iota constants.
    fmt.Println(Low)
    fmt.Println(Medium)
    fmt.Println(High)
}

Provalo in Go Playground

Modified text is an extract of the original Stack Overflow Documentation

Autorizzato sotto CC BY-SA 3.0

Non affiliato con Stack Overflow

Go
Iota

Ricerca…