:= et = en Go : quelle est la différence ? Analyse complète avec exemples

Introduction : pourquoi la confusion entre := et = peut casser votre code Go

Vous écrivez en Go, tout se passe bien, mais soudain le compilateur affiche l'erreur no new variables on left side of :=. Cela vous dit quelque chose ? Ou vous voyez le code d'un collègue qui utilise tantôt =, tantôt :=, et il semble qu'il n'y ait pas de différence. En réalité, la différence est fondamentale, et ne pas la comprendre est l'une des erreurs les plus fréquentes chez les débutants en Golang.

Dans ce guide, nous allons voir en quoi les opérateurs := (short variable declaration) et = (assignment) diffèrent. Vous apprendrez quand utiliser l'un ou l'autre, comment éviter les erreurs et comment écrire un code Go plus propre et idiomatique. C'est parti !

Les bases : que sont les variables et à quoi servent-elles ?

Avant de plonger dans les détails des opérateurs, rappelons qu'une variable est une zone mémoire nommée qui stocke une valeur d'un type donné. En Go, comme dans tout langage fortement typé, il faut manipuler les variables avec précaution.

Les opérateurs := et = sont deux façons d'interagir avec les variables, mais ils résolvent des problèmes différents. Le premier déclare une variable, le second modifie sa valeur.

Opérateur = (affectation) : seulement la modification, pas de déclaration

L'opérateur = est l'affectation classique. Il prend une variable déjà existante et y écrit une nouvelle valeur. Si la variable n'existe pas, le compilateur générera une erreur.

package main\n\nimport "fmt"\n\nfunc main() {\n    var name string  // déclaration explicite de la variable\n    name = "Go"      // affectation d'une valeur (fonctionne)\n    fmt.Println(name)\n\n    // age = 10       // ERREUR : la variable age n'est pas déclarée\n}\n

Ici, name a été déclarée avec var, nous pouvons donc utiliser =. Si nous avions essayé d'écrire age = 10 sans déclaration préalable, le compilateur aurait refusé de compiler le code.

Quand utiliser = ?

\n
• Lorsque la variable est déjà déclarée (via var ou :=).
\n
• Dans les boucles et itérations pour mettre à jour des compteurs.
\n
• Lorsqu'on travaille avec des pointeurs et des structures, où il faut modifier un champ.
\n

Opérateur := (déclaration courte) : déclaration + affectation en une seule étape

L'opérateur := est un "sucre syntaxique" qui déclare une variable et lui affecte une valeur simultanément. Le type de la variable est déduit automatiquement de l'expression à droite. C'est beaucoup plus court que d'écrire var x int = 5.

package main\n\nimport "fmt"\n\nfunc main() {\n    name := "Go"   // déclaration et affectation, type string\n    age := 10      // déclaration et affectation, type int\n    fmt.Println(name, age)\n}\n

C'est équivalent à :

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

Mais := est plus court et plus facile à lire. La règle principale est : à gauche de :=, il doit y avoir au moins une nouvelle variable. Si toutes les variables sont déjà déclarées, vous obtiendrez une erreur.

Quand utiliser := ?

\n
• Pour déclarer des variables locales à l'intérieur des fonctions.
\n
• Dans les boucles for, if et switch avec une initialisation courte.
\n
• Lorsqu'on travaille avec des fonctions qui retournent plusieurs valeurs (par exemple, err := someFunc()).
\n

La différence principale : déclaration vs modification

La différence la plus importante à retenir :

\n
• := est une déclaration. Elle crée une nouvelle variable dans la portée actuelle.
\n
• = est une affectation. Elle modifie une variable existante.
\n

Essayez de voir cela comme la différence entre la "naissance" d'une variable et le "changement de son nom". Vous ne pouvez pas changer un