:= e = em Go: qual a diferença? Análise completa com exemplos

Introdução: por que a confusão entre := e = pode quebrar seu código Go

Você está programando em Go, tudo está indo bem, mas de repente o compilador exibe o erro no new variables on left side of :=. Familiar? Ou você vê o código de um colega, onde ele usa = e :=, e parece que não há diferença. Na verdade, a diferença é fundamental, e não entender isso é um dos erros mais comuns entre iniciantes em Golang.

Neste guia, vamos analisar como os operadores := (short variable declaration) e = (assignment) diferem. Você aprenderá quando usar cada um, como evitar erros e como escrever um código Go mais limpo e idiomático. Vamos lá!

Fundamentos: o que são variáveis e para que servem?

Antes de mergulharmos nos detalhes dos operadores, vamos lembrar que uma variável é uma área de memória nomeada que armazena um valor de um tipo específico. Em Go, como em qualquer linguagem fortemente tipada, é preciso trabalhar com variáveis com cuidado.

Os operadores := e = são duas formas de interagir com variáveis, mas resolvem tarefas diferentes. O primeiro declara uma variável, o segundo altera seu valor.

Operador = (atribuição): apenas alteração, sem declaração

O operador = é a atribuição clássica. Ele pega uma variável já existente e atribui um novo valor a ela. Se a variável não existir, o compilador exibirá um erro.

package main\n\nimport "fmt"\n\nfunc main() {\n    var name string  // declaramos a variável explicitamente\n    name = "Go"      // atribuímos o valor (funciona)\n    fmt.Println(name)\n\n    // age = 10       // ERRO: variável age não foi declarada\n}\n

Aqui, name foi declarada usando var, então podemos usar =. Se tentássemos escrever age = 10 sem declaração prévia, o compilador se recusaria a compilar o código.

Quando usar =?

\n
• Quando a variável já foi declarada (via var ou :=).
\n
• Em loops e iterações para atualizar contadores.
\n
• Ao trabalhar com ponteiros e estruturas, onde é necessário alterar um campo.
\n

Operador := (declaração curta): declaração + atribuição em um único passo

O operador := é um "açúcar sintático" que declara uma variável e atribui um valor a ela simultaneamente. O tipo da variável é inferido automaticamente a partir da expressão à direita. É muito mais curto do que escrever var x int = 5.

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

Isso é equivalente a:

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

Mas := é mais curto e mais fácil de ler. A regra principal é: à esquerda de := deve haver pelo menos uma nova variável. Se todas as variáveis já foram declaradas, você receberá um erro.

Quando usar :=?

\n
• Para declarar variáveis locais dentro de funções.
\n
• Em loops for, if e switch com inicialização curta.
\n
• Ao trabalhar com funções que retornam múltiplos valores (por exemplo, err := someFunc()).
\n

Diferença principal: declaração vs alteração

A diferença mais importante a ser lembrada é:

\n
• := é uma declaração (declaration). Ela cria uma nova variável no escopo atual.
\n
• = é uma atribuição (assignment). Ela altera uma variável existente.
\n

Tente imaginar isso como a diferença entre "criar" uma variável e "mudar seu nome". Você não pode alterar e