const en Golang: constantes con tipo y sin tipo

Una constante es un valor fijado en tiempo de compilación. Se declara con const, y Go rechaza cualquier intento de cambiarla.

package main

import (
	"fmt"
	"time"
)

const AppName = "inventory"
const MaxRetries = 3
const Timeout = 2 * time.Second

const (
	KB = 1024
	MB = 1024 * KB
	GB = 1024 * MB
)

func main() {
	fmt.Println(AppName, MaxRetries, Timeout)
	fmt.Println("1 GB =", GB, "bytes")
	fmt.Printf("upload limit: %.1f MB\n", 15_000_000.0/MB)
}

Las constantes se pueden declarar a nivel de paquete o dentro de una función, una por línea o agrupadas en un bloque const ( ... ). MB y GB se calculan a partir de otras constantes, y el compilador hace esa aritmética una sola vez, al compilar.

Asignar a una constante, como MaxRetries = 5, es un error de compilación:

./main.go:8:2: cannot assign to MaxRetries (neither addressable nor a map index expression)

Qué puede ser una constante

Solo tres clases de valores: booleanos, números (enteros, flotantes, complejos y runes) y strings. El compilador tiene que poder calcular el valor, lo que significa literales, otras constantes, aritmética sobre ellas y unas pocas funciones integradas como len de un string constante.

Todo lo que necesite ejecutar código o reservar memoria queda fuera:

const Colors = []string{"red", "green"} // slice
const Started = time.Now()              // function call

./main.go:9:16: []string{…} (value of type []string) is not constant
./main.go:10:13: time.Now() (value of struct type time.Time) is not constant

Por qué Go no tiene slices ni maps constantes

Los slices, los maps y los structs que los contienen son referencias a memoria que existe en tiempo de ejecución, así que el compilador no puede incrustarlos en el programa como valores fijos, y Go no tiene un modificador readonly ni final para variables. Las alternativas habituales:

package main

import (
	"fmt"
	"slices"
)

// A package-level var: fine when your own code is the only writer.
var weekdays = []string{"Mon", "Tue", "Wed", "Thu", "Fri"}

// A function returning a fresh copy: callers cannot change the original.
func Weekdays() []string {
	return slices.Clone(weekdays)
}

// An array has a fixed length, but it is still a var, not a const.
var primes = [5]int{2, 3, 5, 7, 11}

func main() {
	days := Weekdays()
	days[0] = "Monday" // changes the copy only

	fmt.Println(days)
	fmt.Println(weekdays)
	fmt.Println(primes, len(primes))
}

La copia cuesta una reserva de memoria por llamada, lo cual está bien para datos del tamaño de una configuración. Para búsquedas por clave, un switch dentro de una función es otra opción que se comporta como una constante: func statusText(code int) string { switch code { ... } }.

Constantes sin tipo

Una constante declarada sin tipo es sin tipo (untyped). Tiene una clase (entero, flotante, rune, string, bool) pero ningún tipo Go concreto hasta que se usa, y se adapta al contexto:

package main

import "fmt"

const Ratio = 2 // untyped integer constant

func main() {
	var a int = Ratio
	var b float64 = Ratio
	var c uint8 = Ratio
	var d float32 = Ratio * 1.5

	fmt.Println(a, b, c, d)
	fmt.Printf("%T %T %T %T\n", a, b, c, d)

	// When nothing forces a type, the default type is used.
	x := Ratio
	y := Ratio * 1.5
	fmt.Printf("x is %T, y is %T\n", x, y)
}

Ratio funciona como int, float64, uint8 y float32 sin ninguna conversión. Por eso compila time.Sleep(2 * time.Second): 2 no tiene tipo y se convierte en un time.Duration.

Cuando el contexto no exige un tipo, como en x := Ratio, la constante recibe su tipo por defecto:

Aritmética exacta

Las constantes numéricas sin tipo son exactas. El compilador representa los enteros con al menos 256 bits, así que los valores intermedios pueden ser mucho mayores que cualquier tipo de Go:

package main

import "fmt"

const Huge = 1 << 100
const Scaled = Huge >> 98 // 4: fits in an int

func main() {
	fmt.Println(Scaled)
	fmt.Println(Huge / (1 << 90)) // 1024
}

Huge no se puede imprimir como entero, porque pasarla a fmt.Println la convierte en int, y el compilador lo detecta (float64(Huge) sí funciona, porque un flotante puede contener esa magnitud):

cannot use Huge (untyped int constant 1267650600228229401496703205376) as int value in argument to fmt.Println (overflows)

La misma comprobación detiene errores más pequeños en tiempo de compilación, como var b byte = 300:

cannot use 300 (untyped int constant) as byte value in variable declaration (overflows)

Constantes con tipo

Si le das un tipo a una constante, se comporta como un valor de ese tipo en todas partes, incluida la negativa de Go a mezclar tipos:

const Limit int = 10

var f float64 = 2
fmt.Println(Limit * f)

invalid operation: Limit * f (mismatched types int and float64)

Con const Limit = 10 (sin tipo), Limit * f compila y da 20. Así que deja las constantes sin tipo salvo que el tipo aporte significado. Lo aporta cuando declaras constantes de un tipo con nombre propio, que es como Go construye los enums:

type Weekday int

const (
	Sunday Weekday = iota
	Monday
	Tuesday
)

Aquí el tipo es lo importante: una función que recibe un Weekday documenta lo que espera. iota y los patrones de enum basados en él se explican en la página de enums e iota.

const frente a var

Usa const para todo lo que sea realmente fijo: límites, tamaños, nombres, códigos de protocolo, cadenas de formato. Obtienes gratis comprobaciones de desbordamiento en tiempo de compilación y aritmética exacta.

Trampas

Las constantes con tipo no se adaptan. const Timeout int = 5 no se puede pasar donde se espera un time.Duration sin una conversión; una const Timeout = 5 sin tipo sí se puede multiplicar: Timeout * time.Second.

La división entera ocurre con constantes enteras. const Half = 1 / 2 vale 0, porque los dos operandos son enteros sin tipo. Escribe 1.0 / 2 para obtener 0.5.

Sin dirección. &MaxRetries no compila. Si una API quiere un *int, copia antes la constante en una variable.