Variables en Golang: var, :=, valores cero y sombreado

Go tiene dos formas de declarar una variable: var, que funciona en cualquier sitio, y :=, una forma corta que funciona dentro de funciones e infiere el tipo.

package main

import "fmt"

func main() {
	var city string = "Lisbon" // explicit type and value
	var year = 2026            // type inferred as int
	var score int              // no value: zero value 0
	name := "Ana"              // short declaration, inferred string

	fmt.Println(city, year, score, name)
	fmt.Printf("%T %T %T %T\n", city, year, score, name)
}

Cada variable tiene un tipo fijo decidido en tiempo de compilación. Cuando le das un valor, Go infiere el tipo a partir de él, así que escribir también el tipo (var city string = "Lisbon") es válido pero redundante.

var frente a :=

La elección idiomática dentro de una función:

• x := value cuando tienes un valor inicial.
• var x T cuando quieres el valor cero, lo que indica "vacío a propósito": var buf bytes.Buffer, var total int.
• var x T = value cuando el tipo inferido no es el que quieres, por ejemplo var ratio float64 = 1 (un ratio := 1 a secas sería un int).

:= fuera de una función es un error de sintaxis:

./main.go:5:1: syntax error: non-declaration statement outside function body

Valores cero

Una variable declarada sin valor nunca contiene basura. Contiene el valor cero de su tipo:

package main

import "fmt"

type Point struct {
	X, Y int
}

func main() {
	var i int
	var f float64
	var b bool
	var s string
	var p *int
	var sl []int
	var m map[string]int
	var pt Point

	fmt.Println(i, f, b, s == "", p, sl == nil, m == nil, pt)
	fmt.Println(len(sl), len(m), m["missing"])
}

Las buenas APIs de Go se diseñan para que el valor cero sea útil: un sync.Mutex a cero está desbloqueado, un bytes.Buffer a cero está vacío y listo, y len, range y append funcionan con un slice nil. El que hay que vigilar es el map: leer un map nil devuelve valores cero, pero escribir en uno provoca un panic. Crea los maps con make o con un literal antes de guardar nada en ellos.

Declarar varias variables

package main

import "fmt"

var (
	appName = "inventory"
	version = "1.4.0"
	debug   bool
)

func main() {
	var width, height int = 1920, 1080
	x, y := 3, 4
	first, count := "widget", 12

	fmt.Println(appName, version, debug)
	fmt.Println(width, height, x, y, first, count)

	// swap without a temporary variable
	x, y = y, x
	fmt.Println("after swap:", x, y)
}

El bloque var ( ... ) agrupa variables relacionadas a nivel de paquete. En una asignación múltiple como x, y = y, x, todas las expresiones de la derecha se evalúan antes de asignar nada, y por eso funciona el intercambio.

:= con varios nombres no redeclara nada mientras al menos un nombre de la izquierda sea nuevo. Los nombres que ya existen en el mismo ámbito simplemente se asignan. Esto es lo que permite reutilizar err:

f, err := os.Open("a.txt")   // declares f and err
g, err := os.Open("b.txt")   // declares g, assigns to the existing err

Si ninguno de los nombres es nuevo, es un error:

./main.go:7:4: no new variables on left side of :=

Usa un = normal para asignar a una variable que ya existe.

Las variables sin usar son errores

Una variable local que se declara pero nunca se lee detiene la compilación:

./main.go:9:2: declared and not used: x

No es un aviso que puedas desactivar. Borra la variable, úsala o, mientras depuras, siléncialo con el identificador vacío: _ = x. El identificador vacío también descarta los valores de retorno que no necesitas: _, err := fmt.Println("hi").

Las variables a nivel de paquete y los parámetros de función están exentos de esta regla.

Ámbito y sombreado

Una variable existe desde su declaración hasta el final del bloque que la contiene ({ ... }). Un := en un bloque interior crea una variable nueva, aunque exista fuera una con el mismo nombre. La exterior queda sombreada, no cambia:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	count := 0
	input := "42"

	if input != "" {
		count, err := strconv.Atoi(input) // new count, only inside this block
		if err != nil {
			fmt.Println("error:", err)
			return
		}
		fmt.Println("inside:", count)
	}

	fmt.Println("outside:", count) // still 0
}

El programa imprime inside: 42 y luego outside: 0. El := dentro del if declaró count y err como variables nuevas en el bloque interior, porque ninguna existía todavía ahí. Compila sin problemas y es una fuente clásica de bugs del tipo "mi valor ha desaparecido".

El arreglo es declarar antes err y asignar con =:

var err error
count, err = strconv.Atoi(input)

go vet no informa del sombreado por defecto. El analizador aparte shadow sí, y linters como golangci-lint pueden activarlo.

Nombres

• Usa camelCase: maxRetries, userID. No max_retries.
• Mantén las siglas en un mismo tipo de letra: userID, httpClient, parseURL, no userId.
• Nombres cortos para ámbitos cortos: i en un bucle, r para un reader, err para un error. Nombres más largos y descriptivos para las variables a nivel de paquete.
• Un nombre con mayúscula inicial a nivel de paquete (var Timeout) se exporta a otros paquetes. Consulta paquetes e imports.

Variables a nivel de paquete

Las variables declaradas fuera de las funciones viven durante todo el programa y se inicializan antes de que se ejecute main, en orden de dependencias. Son cómodas para configuración y cachés, y las comparten todas las goroutines. Si más de una goroutine escribe en una, protégela con un mutex o usa sync/atomic, o tendrás una carrera de datos.

Prefiere las constantes para los valores que nunca cambian. Una const no se puede modificar por accidente y no cuesta nada en tiempo de ejecución.