Go => Jota

Invoering

Iota biedt een manier om numerieke constanten te declareren vanaf een startwaarde die monotoon groeit. Iota kan worden gebruikt om bitmaskers te declareren die vaak worden gebruikt in systeem- en netwerkprogrammering en andere lijsten met constanten met gerelateerde waarden.

Opmerkingen

De iota ID wordt gebruikt om waarden toe te wijzen aan lijsten met constanten. Wanneer iota in een lijst wordt gebruikt, begint het met een waarde van nul en wordt het met één verhoogd voor elke waarde in de lijst met constanten en wordt het gereset voor elk const sleutelwoord. In tegenstelling tot de opsommingen van andere talen, kan iota worden gebruikt in uitdrukkingen (bijv. iota + 1 ), wat een grotere flexibiliteit mogelijk maakt.

Eenvoudig gebruik van iota

Om een lijst met constanten te maken, wijst u iota waarde toe aan elk element:

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

Om een lijst met constanten op een verkorte manier te maken, wijst u iota waarde toe aan het eerste element:

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

Iota gebruiken in een uitdrukking

iota kan in uitdrukkingen worden gebruikt, dus het kan ook worden gebruikt om andere waarden toe te wijzen dan eenvoudige oplopende gehele getallen vanaf nul. Gebruik dit voorbeeld van Effective Go om constanten voor SI-eenheden te maken:

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
)

Waarden overslaan

De waarde van iota wordt nog steeds verhoogd voor elk item in een constante lijst, zelfs als iota niet wordt gebruikt:

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
)

het wordt ook verhoogd als er helemaal geen constante wordt gemaakt, wat betekent dat de lege identifier kan worden gebruikt om waarden volledig over te slaan:

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

Het eerste codeblok is afkomstig van de Go Spec (CC-BY 3.0).

Gebruik van iota in een uitdrukkingslijst

Omdat iota na elke ConstSpec wordt ConstSpec , hebben waarden in dezelfde expressielijst dezelfde waarde voor 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
)

Dit voorbeeld is afkomstig van de Go Spec (CC-BY 3.0).

Gebruik van iota in een bitmasker

Iota kan erg handig zijn bij het maken van een bitmasker. Om bijvoorbeeld de status van een netwerkverbinding weer te geven die veilig, geverifieerd en / of gereed is, kunnen we een bitmasker maken zoals het volgende:

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

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

Gebruik van iota in const

Dit is een opsomming van const-creatie. Go compiler start iota vanaf 0 en wordt met één verhoogd voor elke volgende constante. De waarde wordt bepaald tijdens het compileren in plaats van tijdens het uitvoeren. Daarom kunnen we iota niet toepassen op expressies die tijdens runtime worden geëvalueerd.

Programma om iota te gebruiken 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)
}

Probeer het in Go Playground

Modified text is an extract of the original Stack Overflow Documentation

Licentie onder CC BY-SA 3.0

Niet aangesloten bij Stack Overflow

Go
Jota

Zoeken…