Boucle while en Golang : écrire while et do-while en Go

Go n'a pas de mot-clé while. Écrivez for suivi d'une condition, et vous avez une boucle while :

package main

import "fmt"

func main() {
	balance := 1000.0
	years := 0

	for balance < 2000 {
		balance *= 1.07
		years++
	}

	fmt.Printf("doubled after %d years: %.2f\n", years, balance)
}

La condition est testée avant chaque itération, donc si elle est fausse au départ, le corps ne s'exécute jamais. C'est identique à while (balance < 2000) en C, Java ou JavaScript, sans les parenthèses ni le mot-clé. Les concepteurs de Go ont choisi un seul mot-clé pour toutes les formes de boucle ; voir la page sur la boucle for pour les quatre formes.

while(true) : la boucle infinie

Omettez complètement la condition et la boucle tourne jusqu'à ce que quelque chose à l'intérieur y mette fin :

package main

import "fmt"

func main() {
	queue := []string{"email", "resize", "stop", "never-reached"}

	for {
		job := queue[0]
		queue = queue[1:]

		if job == "stop" {
			fmt.Println("stopping")
			break
		}
		fmt.Println("processing", job)
	}

	fmt.Println("left in queue:", queue)
}

for { } est l'écriture idiomatique. for true { } compile aussi, mais donne l'impression que l'auteur vient d'un autre langage.

Quatre choses terminent une boucle infinie : break (quitte la boucle), return (quitte la fonction), un panic, et os.Exit. Un programme dont le main reste dans un for {} sans aucune de ces sorties tourne jusqu'à ce qu'on le tue, ce qui est exactement ce qu'il faut pour un serveur ou un worker.

do-while

Un do-while exécute le corps une fois avant de tester la condition. Go n'a pas de syntaxe dédiée. Placez le test à la fin d'une boucle infinie :

package main

import (
	"fmt"
	"math/rand/v2"
)

func main() {
	r := rand.New(rand.NewPCG(8, 8))

	rolls := 0
	for {
		roll := r.IntN(6) + 1
		rolls++
		fmt.Println("rolled", roll)

		if roll == 6 {
			break
		}
	}
	fmt.Println("needed", rolls, "rolls to get a 6")
}

Le corps s'exécute au moins une fois quoi qu'il arrive, ce qui est la propriété qui définit le do-while. La source aléatoire utilise une graine fixe pour que la sortie soit la même à chaque exécution ; utilisez rand.IntN sans source avec graine pour un vrai hasard.

Une seconde forme garde la condition dans l'en-tête en forçant le premier passage :

for first := true; first || condition(); first = false {
	// body
}

Elle fonctionne, mais la boucle infinie avec un break à la fin se lit plus facilement, et c'est ce que fait la plupart du code Go.

Lire jusqu'à la fin

La boucle while la plus courante dans le vrai code Go lit une entrée jusqu'à épuisement. bufio.Scanner est conçu pour cela : Scan renvoie false à la fin de l'entrée ou en cas d'erreur, c'est donc la condition de la boucle :

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	input := "first line\nsecond line\nthird line\n"
	scanner := bufio.NewScanner(strings.NewReader(input))

	n := 0
	for scanner.Scan() {
		n++
		fmt.Printf("%d: %s\n", n, scanner.Text())
	}
	if err := scanner.Err(); err != nil {
		fmt.Println("read error:", err)
	}
}

Remplacez strings.NewReader(input) par os.Stdin et la même boucle lit la saisie de l'utilisateur ligne par ligne. Vérifiez scanner.Err() après la boucle : un Scan qui renvoie false ne vous dit pas si l'entrée s'est terminée normalement ou a échoué.

break et continue

Les deux fonctionnent dans toutes les formes de for :

package main

import "fmt"

func main() {
	n := 0
	for n < 20 {
		n++
		if n%3 != 0 {
			continue // back to the condition check
		}
		if n > 12 {
			break
		}
		fmt.Print(n, " ")
	}
	fmt.Println()
}

Dans une boucle à condition seule, continue saute directement à la condition. Cela rend facile un bug subtil : si le compteur est mis à jour en bas du corps, un continue placé au-dessus saute la mise à jour et la boucle ne se termine jamais. Mettez le compteur à jour en haut, comme ci-dessus, ou utilisez un for à trois clauses dont l'instruction post s'exécute même après continue.

Attendre quelque chose

Une boucle qui attend une condition doit bloquer ou dormir, pas tourner à vide :

// Wrong: burns a CPU core while waiting
for !ready {
}

// Better: poll with a delay
for !isReady() {
	time.Sleep(100 * time.Millisecond)
}

Interroger en boucle une simple variable qu'une autre goroutine écrit est aussi une data race. Entre goroutines, attendez plutôt sur un channel, un sync.WaitGroup ou un sync.Cond, ou utilisez select avec un timer. Pour les boucles de nouvelles tentatives avec une limite, préférez un for compté pour que la boucle ne puisse pas tourner indéfiniment :

for attempt := 1; attempt <= 5; attempt++ {
	if err := connect(); err == nil {
		break
	}
	time.Sleep(time.Duration(attempt) * 200 * time.Millisecond)
}

Erreurs courantes

• Oublier de modifier la variable de condition. for i < 10 { fmt.Println(i) } ne se termine jamais. Toute boucle while a besoin de quelque chose dans le corps qui la rapproche de la sortie.
• Écrire while. while x < 5 {} donne syntax error: unexpected name x at end of statement, parce que while n'est pas un mot-clé ; le compilateur le lit comme un nom ordinaire.
• Des parenthèses par habitude. for (x < 5) {} compile, et gofmt retire les parenthèses.
• Déclarer la variable dans la boucle. for n := 10; n > 0 {} est une erreur de syntaxe ; une boucle avec une clause d'initialisation a besoin des trois clauses. Déclarez n avant la boucle, ou écrivez la forme complète à trois clauses.

for count < 10 {
	count++
}

for {
	// body runs at least once
	if !condition {
		break
	}
}