Go => Iota

Introducción

Iota proporciona una forma de declarar constantes numéricas a partir de un valor inicial que crece monótonamente. Iota se puede usar para declarar máscaras de bits que se usan a menudo en la programación de redes y sistemas y otras listas de constantes con valores relacionados.

Observaciones

El identificador iota se utiliza para asignar valores a listas de constantes. Cuando se usa iota en una lista, comienza con un valor de cero, y se incrementa en uno para cada valor en la lista de constantes y se restablece en cada palabra clave const . A diferencia de las enumeraciones de otros idiomas, iota se puede usar en expresiones (por ejemplo, iota + 1 ) que permite una mayor flexibilidad.

Uso simple de iota

Para crear una lista de constantes, asigne un valor iota a cada elemento:

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

Para crear una lista de constantes de forma abreviada, asigne un valor de iota al primer elemento:

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

Usando iota en una expresión

iota se puede usar en expresiones, por lo que también se puede usar para asignar valores que no sean simples enteros incrementales a partir de cero. Para crear constantes para unidades SI, use este ejemplo de 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
)

Valores de salto

El valor de iota aún se incrementa para cada entrada en una lista constante, incluso si no se usa iota:

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
)

también se incrementará incluso si no se crea una constante, lo que significa que el identificador vacío se puede usar para omitir valores por completo:

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

El primer bloque de código se tomó de Go Spec (CC-BY 3.0).

Uso de iota en una lista de expresiones.

Debido a que iota se incrementa después de cada ConstSpec , los valores dentro de la misma lista de expresiones tendrán el mismo valor para 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
)

Este ejemplo fue tomado de Go Spec (CC-BY 3.0).

Uso de iota en una máscara de bits.

Iota puede ser muy útil al crear una máscara de bits. Por ejemplo, para representar el estado de una conexión de red que puede ser segura, autenticada y / o lista, podríamos crear una máscara de bits como la siguiente:

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

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

Uso de iota en const.

Esta es una enumeración para la creación de const. Ir compilador inicia iota desde 0 e incrementa en uno para cada constante siguiente. El valor se determina en tiempo de compilación en lugar de tiempo de ejecución. Debido a esto, no podemos aplicar iota a las expresiones que se evalúan en tiempo de ejecución.

Programa para usar iota en 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)
}

Pruébalo en Go Playground

Modified text is an extract of the original Stack Overflow Documentation

Licenciado bajo CC BY-SA 3.0

No afiliado a Stack Overflow

Go
Iota

Buscar..