Variables, Constantes y Ámbito
Go ofrece varias formas de introducir nombres, cada una con diferentes reglas de ámbito y restricciones en tiempo de compilación.
//
Busca en todas las páginas de la documentación
Go ofrece varias formas de introducir nombres, cada una con diferentes reglas de ámbito y restricciones en tiempo de compilación.
Saber qué forma usar mantiene el código legible y evita sutiles errores de clausura de bucle.
Las variables almacenan valores en tiempo de ejecución; las constantes son fijas en tiempo de compilación.
El ámbito es léxico: los bloques internos pueden sombrear nombres externos, pero los nombres a nivel de paquete son visibles entre archivos del mismo paquete.
La declaración corta (:=) es la opción idiomática dentro de las funciones, mientras que var y const funcionan a nivel de paquete.
iota genera secuencias de constantes relacionadas sin numeración manual.
Tarjeta de receta de referencia rápida, lista para copiar y pegar.
package main
import "fmt"
const Version = "1.0.0"
var defaultPort = 8080
func main() {
host := "localhost"
port := defaultPort
fmt.Println(host, port, Version)
}Cuándo usar esto:
:= para variables locales dentro de funciones cuando el tipo sea inferible claramente.var a nivel de paquete o cuando necesites un valor cero explícito sin asignación.const para valores que no deben cambiar y para enumeraciones iota.package main
import "fmt"
const (
StatusPending = iota
StatusActive
StatusDone
)
var registry = map[string]int{}
func main() {
for _, name := range []string{"ada", "grace"} {
registry[name] = StatusPending
}
// Trampa de clausura: captura la variable del bucle mediante un parámetro, no por referencia.
for _, name := range []string{"ada", "grace"} {
go greet(name)
}
fmt.Println(registry)
}
func greet(name string) {
fmt.Println("hello", name)
}Lo que esto demuestra:
iota para estados ordenados sin números mágicos.var a nivel de paquete para estado mutable compartido (usar con cuidado).:= local de función dentro de main.name como parámetro a greet evita el clásico error de clausura de variable de bucle.main según el orden de dependencia entre paquetes.const deben ser computables en tiempo de compilación (literales, aritmética sobre constantes, iota).:= reutiliza nombres en el mismo bloque solo cuando al menos un nombre del lado izquierdo es nuevo.| Formulario | Dónde | Ejemplo | Notas |
|---|---|---|---|
var x T | paquete o función | var n int | Valor cero si no hay inicializador |
var x = v | paquete o función | var port = 8080 | Tipo inferido |
x := v | solo función | host := "local" | Al menos un nombre nuevo por bloque |
const x = v | paquete o función | const Max = 100 | Solo tiempo de compilación |
const ( + iota | paquete o función | ver Receta | Se reinicia por bloque const |
| Ámbito | Visible desde | Sombreado |
|---|---|---|
| Paquete | Todos los archivos del mismo paquete | El bloque interno puede sombrear el nombre del paquete |
| Función | Todo el cuerpo de la función | := en un bloque interno crea una nueva local |
Bloque (if, for) | Solo el cuerpo del bloque | if x := f(); x != nil limita x al if |
// iota con máscaras de bits
const (
FlagRead = 1 << iota
FlagWrite
FlagExec
)
// Tipo explícito en la primera constante fija el tipo para el bloque
const (
KB int = 1 << (10 * iota)
MB
GB
)go func() { fmt.Println(i) }() captura una i mutable. Solución: pasa i como parámetro o copia i := i dentro del cuerpo del bucle (Go 1.22+ crea variables por iteración en for range).:= - x := 1 dentro de un bloque interno oculta la x externa y puede confundir a los lectores. Solución: usa nombres distintos o asigna x = 1 al reutilizar la variable externa._ para descartes intencionales.:= a nivel de paquete - La declaración corta es ilegal fuera de las funciones. Solución: usa var o const en el ámbito del paquete.int8 pueden truncarse silenciosamente en algunas conversiones. Solución: usa constantes tipadas o conversión explícita con comprobaciones de límites.| Alternativa | Usar Cuando | No Usar Cuando |
|---|---|---|
Locales := | La mayoría de los cuerpos de función | Declaraciones a nivel de paquete |
var con valor cero | Necesitas explícitamente el cero del tipo | Una simple := con inicializador es más clara |
const + iota | Enumeraciones y banderas de bits | Los valores deben calcularse en tiempo de ejecución |
| Parámetros de función sobre globales | Pruebas y claridad | Rutas críticas donde el perfilado muestra que el costo del parámetro importa (raro) |
var funciona en el ámbito del paquete y de la función y puede declarar sin inicializador (valor cero).
:= solo funciona dentro de las funciones y requiere un inicializador mientras infiere el tipo.
Sí, si al menos un nombre en el lado izquierdo es nuevo.
a, b := 1, 2 luego a, c := 3, 4 reutiliza a y declara c.
iota se reinicia a 0 al comienzo de cada bloque const ( e incrementa en uno por cada línea de especificación de constante, incluidas las líneas en blanco con _.
Las constantes no son almacenamiento; son valores de tiempo de compilación insertados o utilizados en la verificación de tipos.
Asignar una constante a una variable materializa un valor en tiempo de ejecución.
Las locales no utilizadas generalmente indican código muerto o refactorizaciones incompletas.
El compilador exige su eliminación para mantener limpios los binarios y las revisiones.
if err := do(); err != nil {
// err solo existe en esta cadena if/else
}La variable declarada en el inicializador if tiene ámbito para toda la declaración if, incluidas las ramas else.
Si el valor nunca cambia, prefiere const.
Si necesitas un puntero, slice o mapa que sea mutable pero la referencia sea fija, var es apropiado.
Puedes sombrear una importación con una variable local del mismo nombre en un bloque, lo que interrumpe el acceso a la importación dentro de ese bloque.
Renombra las importaciones con import fmt2 "fmt" para evitar colisiones.
Cada iteración ahora crea sus propias variables de bucle, reduciendo los errores de captura de clausura.
Aún así, pasa las variables de bucle a las gorutinas explícitamente cuando te dirijas a versiones anteriores de Go o por claridad.
Las constantes sin tipo son flexibles entre tipos numéricos (const x = 1).
Las constantes tipadas (const x int64 = 1) fuerzan un único tipo en las expresiones.
Solo valores representables en tiempo de compilación: cadenas, números, booleanos y expresiones constantes derivadas.
Los structs, slices y mapas requieren var.
_ descarta un valor pero aún cuenta como un nombre a la izquierda para las reglas de redeclaración.
_, err := f() declara err si es nuevo en el bloque.
var te da sin inicializadorVersiones de Stack: Esta página fue escrita para Go 1.26.x (Green Tea GC por defecto, go fix modernizers - verificar parche en la compilación), chi (última - verificar en la compilación), gin (última - verificar en la compilación), echo (última - verificar en la compilación), google.golang.org/grpc (última - verificar en la compilación), sigs.k8s.io/controller-runtime (última - verificar en la compilación), kubebuilder (última - verificar en la compilación), tinygo (última - verificar objetivos de placa en la compilación), wazero (última - verificar en la compilación) y golangci-lint (última - verificar conjunto de linters en la compilación).
Revisado por Chris St. John·Última actualización: 18 jul 2026