Constantes con iota

12-01-2025
Tiempo de lectura: 1 minutos

En el lenguaje de programación Go, iota es un identificador especial predeclarado incorporado que simplifica la definición de constantes incrementales.

Definir constantes

Definir constantes

Es particularmente útil cuando necesitas definir una serie de constantes relacionadas que siguen un patrón predecible.

iota es una palabra clave en Golang que contiene un valor entero. Se utiliza normalmente en declaraciones de constantes para generar una serie de valores relacionados, que se incrementan en 1 para cada constante subsiguiente.

Dias de la semana

Podemos definir la secuencia de días de la semana, de manera que iota asigna los valores numéricos que representan cada constante:

const (
    Sunday    = iota // 0
    Monday    = iota // 1
    Tuesday   = iota // 2
    Wednesday = iota // 3
    Thursday  = iota // 4
    Friday    = iota // 5
    Saturday  = iota // 6
)

De hecho, no es necesario repetir iota:

const (
    Sunday = iota // 0
    Monday        // 1
    Tuesday       // 2
    Wednesday     // 3
    Thursday      // 4
    Friday        // 5
    Saturday      // 6
)

Obtenemos un mapeado entre las constantes y el valor que representan. El tipo de constante es un int pero podemos utilizar un tipo definido manualmente para aclarar un poco más.

type DayOfWeek int
const ( 
    Monday DayOfWeek = iota // 0 
    Tuesday                 // 1 
    Wednesday               // 2 
    Thursday                // 3 
    Friday                  // 4 
    Saturday                // 5 
    Sunday                  // 6 
)

Expresiones

Ahora, en vez de sumar 1 por defecto, se puede usar un expresión para tener una serie de valores más complicados.

const (
    _ = iota // Discard the first value (0)
    KB = 1 << (10 * iota) // 1 << (10 * 1)
    MB = 1 << (10 * iota) // 1 << (10 * 2)
    GB = 1 << (10 * iota) // 1 << (10 * 3)
    TB = 1 << (10 * iota) // 1 << (10 * 4)
    PB = 1 << (10 * iota) // 1 << (10 * 5)
)

La expresión 1 << (10 * iota) calcula esencialmente la potencia de 2 para el tamaño respectivo. las potencias de 2 simples sería esta:

const ( 
    FlagA = 1 << iota // 1  
    FlagB             // 2 
    FlagC             // 4 
)

Múltiples constantes

Se puede crear diferentes grupos de constantes en el mismo bloque de programa. iota se reinicia en cada bloque const()

const (
    UNCERO = iota // 0
    UNUNO         // 1
)

const (
    OTROCERO = iota // 0
    OTROUNO         // 1
)

Evitar el cero

Podemos evitar el valor inicial de cero de dos formas:

const (
	_ = iota
	primero    // 1
	segundo    // 2
	tercero    // 3
)

O bien

const (
	primero = iota + 1  // 1
	segundo             // 2
	tercero             // 3
)

Saltar valores

Se puede hacer que se salten algunos valores que no sean necesarios. Por ejemplo, podemos asignar valores 1, 2, 3 a las constantes de colores:

const (
	_ = iota
	rojo       // 1
	verde      // 2
	azul       // 3
)

Podemos asignar los valores 1, 3, 5

const (
	_ = iota
	rojo       // 1
	_
	verde      // 3
	_
	azul       // 5
)

En grupo

También asigna por pares, si le definimos la regla para ir asignando cada una de las constantes del par:

const (
	alto, bajo int = iota + 2, iota + 3
	cerca, lejos
	izquierda, derecha
)

Da como resultado

alto  = 2, bajo = 3
cerca = 3, lejos = 4
izquierda = 4, derecha = 5

Cuándo no usarlo

Las constantes generadas de esta forma dinámica no se deben utilizar en caso que sean exportadas para prevenir que se hagan cambios en las constantes