Variables en Golang : var, :=, valeurs zéro et masquage

Go a deux façons de déclarer une variable : var, qui fonctionne partout, et :=, une forme courte qui fonctionne dans les fonctions et déduit le type.

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)
}

Chaque variable a un type fixe décidé à la compilation. Quand vous donnez une valeur, Go en déduit le type, donc écrire aussi le type (var city string = "Lisbon") est légal mais redondant.

var ou :=

Le choix idiomatique dans une fonction :

• x := value quand vous avez une valeur de départ.
• var x T quand vous voulez la valeur zéro, ce qui signale « vide exprès » : var buf bytes.Buffer, var total int.
• var x T = value quand le type déduit n'est pas celui que vous voulez, par exemple var ratio float64 = 1 (un simple ratio := 1 serait un int).

:= hors d'une fonction est une erreur de syntaxe :

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

Valeurs zéro

Une variable déclarée sans valeur ne contient jamais n'importe quoi. Elle contient la valeur zéro de son type :

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"])
}

Les bonnes API Go sont conçues pour que la valeur zéro soit utile : un sync.Mutex à zéro est déverrouillé, un bytes.Buffer à zéro est vide et prêt, et len, range et append fonctionnent tous sur une slice nil. Celle à surveiller est la map : lire une map nil renvoie des valeurs zéro, mais y écrire provoque un panic. Créez les maps avec make ou un littéral avant d'y stocker quoi que ce soit.

Déclarer plusieurs 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)
}

Le bloc var ( ... ) regroupe des variables liées au niveau du package. Dans une affectation multiple comme x, y = y, x, chaque expression à droite est évaluée avant toute affectation, c'est pourquoi l'échange fonctionne.

:= avec plusieurs noms ne redéclare rien tant qu'au moins un nom à gauche est nouveau. Les noms existants dans la même portée sont simplement affectés. C'est ce qui permet de réutiliser 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 aucun des noms n'est nouveau, c'est une erreur :

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

Utilisez un simple = pour affecter une variable qui existe déjà.

Les variables inutilisées sont des erreurs

Une variable locale déclarée mais jamais lue arrête le build :

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

Ce n'est pas un avertissement que l'on peut désactiver. Supprimez la variable, utilisez-la, ou, pendant le débogage, faites-la taire avec l'identifiant blanc : _ = x. L'identifiant blanc sert aussi à jeter les valeurs de retour dont vous n'avez pas besoin : _, err := fmt.Println("hi").

Les variables au niveau du package et les paramètres de fonction échappent à cette règle.

Portée et masquage

Une variable existe de sa déclaration jusqu'à la fin du bloc englobant ({ ... }). Un := dans un bloc intérieur crée une nouvelle variable, même si une variable du même nom existe à l'extérieur. Celle de l'extérieur est masquée, pas modifiée :

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
}

Le programme affiche inside: 42 puis outside: 0. Le := à l'intérieur du if a déclaré count et err comme nouvelles variables dans le bloc intérieur, parce qu'aucune n'y existait encore. Cela compile sans problème et c'est une source classique de bugs du genre « ma valeur a disparu ».

La correction consiste à déclarer err d'abord et à affecter avec = :

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

go vet ne signale pas le masquage par défaut. L'analyseur séparé shadow le fait, et des linters comme golangci-lint peuvent l'activer.

Nommage

• Utilisez le camelCase : maxRetries, userID. Pas max_retries.
• Gardez les acronymes dans une seule casse : userID, httpClient, parseURL, pas userId.
• Des noms courts pour des portées courtes : i dans une boucle, r pour un reader, err pour une erreur. Des noms plus longs et descriptifs pour les variables au niveau du package.
• Un nom en majuscule au niveau du package (var Timeout) est exporté vers les autres packages. Voir packages et imports.

Variables au niveau du package

Les variables déclarées hors des fonctions vivent pendant tout le programme et sont initialisées avant l'exécution de main, dans l'ordre des dépendances. Elles sont pratiques pour la configuration et les caches, et elles sont partagées par toutes les goroutines. Si plus d'une goroutine y écrit, protégez-la avec un mutex ou utilisez sync/atomic, sinon vous avez une data race.

Préférez les constantes pour les valeurs qui ne changent jamais. Une const ne peut pas être modifiée par accident et ne coûte rien à l'exécution.