:= y = en Go: ¿cuál es la diferencia? Análisis completo con ejemplos

Introducción: por qué la confusión entre := y = puede romper tu código Go

Estás escribiendo en Go, todo va perfecto, pero de repente el compilador muestra el error no new variables on left side of :=. ¿Te suena? O ves el código de un colega donde usa tanto = como :=, y parece que no hay diferencia. En realidad, la diferencia es fundamental, y no entender esto es uno de los errores más comunes entre los principiantes en Golang.

En esta guía, analizaremos en qué se diferencian los operadores := (short variable declaration) y = (assignment). Aprenderás cuándo usar cada uno, cómo evitar errores y cómo escribir código Go más limpio e idiomático. ¡Vamos allá!

Conceptos básicos: ¿qué son las variables y para qué sirven?

Antes de sumergirnos en los detalles de los operadores, recordemos que una variable es un área de memoria con nombre donde se almacena un valor de un tipo específico. En Go, como en cualquier lenguaje fuertemente tipado, hay que trabajar con las variables con cuidado.

Los operadores := y = son dos formas de interactuar con las variables, pero resuelven diferentes tareas. El primero declara una variable, el segundo modifica su valor.

Operador = (asignación): solo modificación, sin declaración

El operador = es la asignación clásica. Toma una variable ya existente y le asigna un nuevo valor. Si la variable no existe, el compilador mostrará un error.

package main\n\nimport "fmt"\n\nfunc main() {\n    var name string  // declaramos la variable explícitamente\n    name = "Go"      // asignamos un valor (funciona)\n    fmt.Println(name)\n\n    // age = 10       // ERROR: la variable age no está declarada\n}\n

Aquí, name fue declarada con var, por lo que podemos usar =. Si hubiéramos intentado escribir age = 10 sin declaración previa, el compilador se negaría a compilar el código.

¿Cuándo usar =?

\n
• Cuando la variable ya está declarada (mediante var o :=).
\n
• En bucles e iteraciones para actualizar contadores.
\n
• Al trabajar con punteros y estructuras, donde se necesita modificar un campo.
\n

Operador := (declaración corta): declaración + asignación en un solo paso

El operador := es "azúcar sintáctico" que declara una variable y le asigna un valor al mismo tiempo. El tipo de la variable se deduce automáticamente de la expresión de la derecha. Es mucho más corto que escribir var x int = 5.

package main\n\nimport "fmt"\n\nfunc main() {\n    name := "Go"   // declaramos y asignamos, tipo string\n    age := 10      // declaramos y asignamos, tipo int\n    fmt.Println(name, age)\n}\n

Esto es equivalente a:

var name string = "Go"\nvar age int = 10\n

Pero := es más corto y más fácil de leer. La regla principal: a la izquierda de := debe haber al menos una variable nueva. Si todas las variables ya están declaradas, obtendrás un error.

¿Cuándo usar :=?

\n
• Para declarar variables locales dentro de funciones.
\n
• En bucles for, if y switch con inicialización corta.
\n
• Al trabajar con funciones que devuelven múltiples valores (por ejemplo, err := someFunc()).
\n

Diferencia principal: declaración vs modificación

La diferencia más importante que debes recordar:

\n
• := es una declaración (declaration). Crea una nueva variable en el ámbito actual.
\n
• = es una asignación (assignment). Modifica una variable existente.
\n

Intenta imaginarlo como la diferencia entre "crear" una variable y "cambiar su nombre". No puedes cambiar una variable que no existe, y no puedes declarar dos veces la misma variable en el mismo ámbito.