Go => Iota

Introduktion

Iota tillhandahåller ett sätt att deklarera numeriska konstanter från ett utgångsvärde som växer monotont. Iota kan användas för att deklarera bitmasks som ofta används i system- och nätverksprogrammering och andra listor över konstanter med relaterade värden.

Anmärkningar

iota identifieraren används för att tilldela värden till listor över konstanter. När iota används i en lista börjar det med ett värde på noll och ökar med ett för varje värde i listan med konstanter och återställs för varje const nyckelord. Till skillnad från antalet andra språk kan iota användas i uttryck (t.ex. iota + 1 ) vilket möjliggör större flexibilitet.

Enkel användning av iota

För att skapa en lista med konstanter - tilldela iota värde till varje element:

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

För att skapa en lista med konstanter på ett förkortat sätt - tilldela det första elementet iota värde:

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

Använda iota i ett uttryck

iota kan användas i uttryck, så det kan också användas för att tilldela andra värden än enkla stegvisa heltal med början från noll. För att skapa konstanter för SI-enheter använder du detta exempel från Effektiv 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
)

Hoppa över värden

Värdet på iota ökas fortfarande för varje post i en konstant lista även om iota inte används:

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
)

det kommer också att ökas även om det inte skapas någon konstant alls, vilket betyder att den tomma identifieraren kan användas för att hoppa över värden helt:

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

Det första kodblocket togs från Go Spec (CC-BY 3.0).

Användning av iota i en uttryckslista

Eftersom iota ökas efter varje ConstSpec kommer värden inom samma uttryckslista att ha samma värde för 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
)

Detta exempel är hämtat från Go Spec (CC-BY 3.0).

Användning av iota i en bitmask

Iota kan vara mycket användbar när du skapar en bitmask. För att exempelvis representera tillståndet för en nätverksanslutning som kan vara säker, autentiserad och / eller redo kan vi skapa en bitmask som följande:

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

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

Användning av iota i const

Detta är en uppräkning för konst skapelse. Go-kompilatorn startar iota från 0 och steg med en för varje följande konstant. Värdet bestäms vid kompileringstid snarare än körtid. På grund av detta kan vi inte tillämpa iota på uttryck som utvärderas vid körning.

Program för att använda iota i 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)
}

Prova på Go Playground

Modified text is an extract of the original Stack Overflow Documentation

Licensierat under CC BY-SA 3.0

Inte anslutet till Stack Overflow

Go
Iota

Sök…