Cuando declaras una variable con var, el programa reserva espacio en memoria y le asigna un valor durante la ejecución (runtime). En cambio, con const, el valor se calcula en el momento en que compilas el código (compile time). Esto hace que las constantes sean extremadamente eficientes y seguras, ya que el compilador las “incrusta” directamente donde se usan y garantiza que nunca cambien. Sin embargo, esta eficiencia tiene un límite: solo puedes usar tipos básicos (números, strings o booleanos) cuyos valores puedas conocer sin ejecutar el programa. No puedes tener una const que sea un slice, un map o un struct, porque esos tipos dependen de la memoria dinámica que solo se asigna al ejecutar.
iota es un identificador especial que solo tiene sentido dentro de un bloque const. Su trabajo es actuar como un contador automático que empieza en 0 y aumenta en 1 cada vez que aparece una nueva línea de declaración en el bloque. Lo interesante es que no solo sirve para contar; puedes usarlo en expresiones matemáticas para crear secuencias complejas, como potencias de dos, lo cual es fundamental para manejar permisos por bits. Un patrón muy común en Go es usar el identificador en blanco _ para “saltar” el valor 0. Esto es vital para evitar errores de lógica: como en Go todas las variables se inicializan con su valor por defecto (zero-value), queremos que ese 0 represente un estado “desconocido” o “inválido”, y no un valor de negocio real.
package main
import "fmt"
// Definimos estados para un servidor.
// Usamos _ para que el valor 0 (default) no sea un estado válido.
const (
_ = iota // 0: Estado desconocido (evitamos colisiones con el zero-value)
StateStopped
StateRunning
StatePaused
)
// Definimos permisos usando máscaras de bits (bitmasks).
// Al iniciar un nuevo bloque const, iota se reinicia a 0.
const (
PermRead = 1 << iota // 1 << 0 = 1
PermWrite // 1 << 1 = 2
PermExecute // 1 << 2 = 4
)
func main() {
// Uso de constantes de estado
estado := StateRunning
fmt.Printf("Estado del servidor: %d\n", estado)
// Uso de constantes de permisos
// Combinamos permisos usando el operador OR (|)
misPermisos := PermRead | PermWrite
fmt.Printf("Mis permisos (bitmask): %d\n", misPermisos)
// Verificamos un permiso específico usando el operador AND (&)
tieneEscritura := (misPermisos & PermWrite) != 0
fmt.Printf("¿Tiene permiso de escritura?: %v\n", tieneEscritura)
// Comprobamos si el valor por defecto (0) es un permiso válido
permisoVacio := 0
fmt.Printf("¿Es un permiso válido?: %v\n", permisoVacio != 0)
}
En el ejemplo anterior, observa cómo gestionamos los estados del servidor. Hemos usado _ = iota para que el primer valor sea 0, pero al asignárselo al identificador en blanco, lo “descartamos”. Esto es crucial porque si declaramos StateStopped como el primer elemento sin el _, este tendría el valor 0. Si alguien crea una variable var estadoTipo pero olvida asignarle un valor, Go le dará automáticamente el 0, lo que significaría que un servidor sin inicializar estaría legalmente en StateStopped. Al usar el patrón _, el 0 queda como un estado inválido.
En el segundo bloque de constantes, aplicamos la potencia de iota para crear una máscara de bits. Al declarar PermRead = 1 << iota, el compilador calcula 1 << 0, que es 1. Lo más potente es que en la siguiente línea, PermWrite, no es necesario repetir la expresión; Go entiende que debe repetir la fórmula 1 << iota pero incrementando el valor de iota a 1, resultando en 1 << 1 = 2. Esto nos permite usar operadores de bits como | para combinar permisos y & para verificar si un usuario posee uno específico.
El error frecuente ocurre cuando intentas usar una función que se ejecuta en tiempo de ejecución para definir una constante. Por ejemplo:
// ESTO DARÁ ERROR DE COMPILACIÓN
const hoy = time.Now()
// ESTO TAMBIÉN
const miMapa = map[string]int{"a": 1}
El compilador no puede “predecir” qué hora será mañana ni qué habrá dentro de un mapa en memoria, por lo que te impedirá declarar estas constantes. Si necesitas que el valor cambie o se calcule al ejecutar, debes usar var.
N° 26