backend / go

Types de base et variables

Leçon 21 exercice

Explication

Ce que vous allez apprendre

Déclarer une variable avec var (typée explicitement ou inférée) et avec :=
Comprendre les "zero values" : pourquoi Go n'a jamais de variable "undefined"
Choisir la bonne taille d'entier (int, int64, uint8...) selon le besoin
Convertir explicitement entre types numériques sans conversion implicite
Utiliser const et iota pour générer des séquences de constantes

Dans quel contexte ?

Un développeur qui vient de Python ou JavaScript ouvre pour la première fois un fichier main.go et tombe sur var age int = 29 : il se demande pourquoi il faut préciser le type alors que la valeur 29 semble déjà évidente. Cette leçon explique cette différence fondamentale de philosophie, qui va conditionner toute la suite de l'apprentissage de Go.

D'abord, une variable en Go a toujours un type fixe

Contrairement à un langage dynamiquement typé, une variable Go ne change jamais de type après sa déclaration. Le compilateur connaît ce type dès la compilation, ce qui lui permet de détecter énormément d'erreurs avant même que le programme ne s'exécute.

Il existe deux façons de déclarer une variable : var nom type = valeur pour être explicite, ou la forme courte nom := valeur qui laisse Go déduire le type depuis la valeur fournie. Cette seconde forme n'est utilisable qu'à l'intérieur d'une fonction, jamais au niveau du package.

Une fois cette base posée, il faut connaître les tailles d'entiers disponibles

Go propose plusieurs tailles d'entiers signés et non signés, chacune adaptée à un besoin précis de mémoire ou de plage de valeurs.

Type	Plage de valeurs	Usage typique
`int8` / `uint8`	-128 à 127 / 0 à 255	Octets bruts, très petites valeurs
`int`	Dépend de la plateforme (64 bits en pratique)	Le choix par défaut recommandé
`int64`	Grands nombres (ex: timestamps Unix)	Calculs qui dépassent 32 bits
`float64`	Décimaux, précision double	Le choix par défaut pour les flottants

En pratique, sauf contrainte précise de mémoire ou d'interopérabilité, int et float64 couvrent la grande majorité des besoins d'un débutant.

Prérequis

Cette leçon suppose que tu as déjà installé Go et lancé ton premier go run (voir la leçon précédente). Aucune autre connaissance n'est nécessaire.

Il reste un point qui surprend systématiquement les nouveaux venus : les zero values

Dans beaucoup de langages, une variable déclarée sans valeur est "indéfinie" ou vaut null/undefined, source classique de bugs. Go supprime ce problème à la racine : toute variable non initialisée reçoit automatiquement sa "zero value" — 0 pour les nombres, "" pour les chaînes, false pour les booléens.

C'est un choix de conception qui élimine une catégorie entière d'erreurs à l'exécution, mais qui demande un temps d'adaptation : il faut apprendre à lire var compteur int comme "compteur vaut déjà 0", pas comme "compteur n'a pas encore de valeur".

Piège fréquent

Go n'effectue jamais de conversion numérique implicite, contrairement à beaucoup de langages. Écrire var f float64 = entier où entier est un int provoque une erreur de compilation : il faut toujours convertir explicitement avec float64(entier). C'est verbeux au début, mais ça évite des bugs de précision silencieux très communs ailleurs.

Pour finir, un outil pratique pour les séquences de valeurs

const associé à iota génère automatiquement des constantes incrémentales, un peu comme un enum dans d'autres langages. C'est très utilisé pour représenter des jours de la semaine, des statuts, ou des niveaux de log sans risquer de dupliquer une valeur par erreur.

Bonne pratique

Préfère toujours := à l'intérieur des fonctions pour la concision, et réserve var explicite aux cas où tu veux documenter clairement un type, ou déclarer une variable sans l'initialiser immédiatement.

Maintenant que tu sais représenter des données, la prochaine étape logique est de savoir comment le programme prend des décisions et répète des actions : direction les structures de contrôle.

Commandes & code

Types de base et variables

Go est statiquement typé : chaque variable a un type connu à la compilation.

package main

import "fmt"

func main() {
	// Declaration explicite
	var age int = 29
	var nom string = "Alice"
	var actif bool = true

	// Inference de type avec var (le type est deduit)
	var taille = 1.68 // float64

	// Forme courte := (idiomatique, uniquement a l'interieur des fonctions)
	pays := "France"
	nbEtudiants := 42

	// Declaration groupee
	var (
		x, y int    = 1, 2
		nomComplet  = "Bob Martin"
	)

	// Types numeriques : tailles explicites
	var i8 int8 = 127
	var u8 uint8 = 255
	var i64 int64 = 9_000_000_000
	var f32 float32 = 3.14
	var f64 float64 = 3.14159265358979

	// Zero values : Go initialise toujours (pas de "undefined")
	var vide string  // ""
	var zero int     // 0
	var faux bool    // false

	// Constantes : valeurs figees a la compilation
	const Pi = 3.14159
	const (
		Lundi = iota // 0
		Mardi        // 1
		Mercredi     // 2
	)

	fmt.Println(age, nom, actif, taille, pays, nbEtudiants, x, y, nomComplet)
	fmt.Println(i8, u8, i64, f32, f64, vide, zero, faux, Pi, Mardi)

	// Conversion explicite obligatoire (pas de conversion implicite en Go)
	var entier int = 42
	var flottant float64 = float64(entier)
	var retour int = int(flottant)
	fmt.Println(entier, flottant, retour)
}

Catégorie	Types
Entiers	`int`, `int8/16/32/64`, `uint8/16/32/64`
Flottants	`float32`, `float64`
Texte	`string`, `rune` (unicode), `byte` (alias `uint8`)
Booléen	`bool`

Résumé

var pour déclarer avec ou sans valeur, := pour inférer localement.
Toute variable non initialisée reçoit sa zero value (jamais indéfinie).
Les conversions numériques sont toujours explicites : float64(x).
const + iota génèrent des séquences de constantes (proche des enums).

Exercices pratiques

1 disponible

Mission : un compteur de stock qui devient négatif tout seul

Objectif : Diagnostiquer un débordement silencieux d'entier de petite taille, puis fiabiliser le typage d'un compteur métier.

Contexte

L'équipe entrepôt a codé un petit outil de suivi de stock en Go. Pour "économiser de la mémoire", un développeur a déclaré var stock int8 = 120. Après une grosse réception de palettes qui ajoute 10 unités, le compteur affiché en base devient étrangement négatif, sans qu'aucune erreur n'apparaisse au build ni à l'exécution.

Résoudre l’exercice →