Les boucles en Go

Go possède un seul mot-clé de boucle : for. Il n’y a ni while ni do. Ce mot-clé unique prend plusieurs formes qui, ensemble, couvrent tous les besoins de répétition.

La boucle for à trois composantes

La forme classique comporte une initialisation, une condition et une post-instruction, séparées par des points-virgules. La boucle tourne tant que la condition vaut true.

for i := 0; i < 5; i++ {
	fmt.Println(i)
}

i est limité à la boucle : il disparaît dès que celle-ci se termine.

La boucle façon while

Retirez l’initialisation et la post-instruction : il reste une boucle à condition seule, l’équivalent d’un while en Go. Les points-virgules disparaissent aussi.

n := 1
for n < 100 {
	n *= 2
}

La boucle infinie

Retirez également la condition et la boucle tourne indéfiniment. On en sort avec break (ou return). Cette forme est courante pour les serveurs et les boucles de lecture.

for {
	line, ok := next()
	if !ok {
		break
	}
	process(line)
}

Parcourir slices et maps avec range

for range parcourt une collection. Sur une slice, il fournit l’indice et une copie de chaque élément :

lettres := []string{"a", "b", "c"}
for i, lettre := range lettres {
	fmt.Println(i, lettre)
}

Sur une map, il fournit la clé et la valeur, dans un ordre non spécifié qui peut changer d’une exécution à l’autre :

stock := map[string]int{"stylos": 4, "livres": 7}
for nom, qte := range stock {
	fmt.Printf("%s : %d\n", nom, qte)
}

break et continue

break arrête la boucle immédiatement ; continue passe à l’itération suivante.

for i := 1; i <= 10; i++ {
	if i%2 != 0 {
		continue // ignore les nombres impairs
	}
	if i > 6 {
		break // s’arrête une fois passé 6
	}
	fmt.Println(i)
}

Les labels pour les boucles imbriquées

Un break ou un continue agit normalement sur la boucle la plus interne. Pour viser une boucle externe, attachez-lui un label :

outer:
for i := 0; i < 3; i++ {
	for j := 0; j < 3; j++ {
		if i+j == 3 {
			break outer
		}
	}
}

Utilisez les labels avec parcimonie : pratiques pour parcourir une grille, ils sont vite abusés.

Un exemple complet

Ce programme parcourt une slice de températures, calcule leur moyenne et trouve le pic. Il compile et s’exécute tel quel.

package main

import "fmt"

func main() {
	temperatures := []float64{18.5, 21.0, 19.5, 24.0, 20.0}

	var sum float64
	max := temperatures[0]

	for i, t := range temperatures {
		sum += t
		if t > max {
			max = t
		}
		fmt.Printf("jour %d : %.1f°C\n", i+1, t)
	}

	moyenne := sum / float64(len(temperatures))
	fmt.Printf("moyenne : %.1f°C, pic : %.1f°C\n", moyenne, max)
}

Son exécution affiche :

jour 1 : 18.5°C
jour 2 : 21.0°C
jour 3 : 19.5°C
jour 4 : 24.0°C
jour 5 : 20.0°C
moyenne : 20.6°C, pic : 24.0°C

Erreurs fréquentes

• Oublier que la valeur de range est une copie. Affecter t dans for i, t := range s ne modifie pas la slice. Écrivez plutôt dans s[i].
• Compter sur l’ordre d’une map. Parcourir une map ne donne aucun ordre stable ; triez d’abord les clés si vous avez besoin de déterminisme.
• Écrire une boucle infinie sans sortie. Un for {} sans break ni return accessible fige le programme.

À vous de jouer

Affichez la table de multiplication de 7, de 7 x 1 à 7 x 10, une ligne par produit, du type 7 x 3 = 21.

package main

import "fmt"

func main() {
	const n = 7
	for i := 1; i <= 10; i++ {
		fmt.Printf("%d x %d = %d\n", n, i, n*i)
	}
}

Résumé

• for est la seule boucle de Go : elle couvre les formes comptée, while et infinie.
• for range parcourt les slices (indice, valeur) et les maps (clé, valeur, sans ordre).
• break, continue et les labels offrent un contrôle précis du déroulement.

Ensuite, regroupez votre logique répétée dans des fonctions, et découvrez les collections que vous parcourez avec les tableaux et slices.