while em Golang: como escrever while e do-while em Go

Go não tem a palavra-chave while. Escreva for seguido de uma condição, e você tem um laço 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)
}

A condição é verificada antes de cada iteração, então se ela for falsa logo no início o corpo nunca executa. É idêntico a while (balance < 2000) em C, Java ou JavaScript, sem os parênteses e sem a palavra-chave. Os criadores do Go escolheram uma única palavra-chave para todos os formatos de laço; veja a página do laço for para as quatro formas.

while(true): o laço infinito

Tire a condição por completo e o laço executa até que algo dentro dele o encerre:

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 { } é a forma idiomática. for true { } também compila, mas parece código de quem veio de outra linguagem.

Quatro coisas encerram um laço infinito: break (sai do laço), return (sai da função), um panic e os.Exit. Um programa cujo main fica em um for {} sem nenhuma delas roda até ser morto, o que é exatamente o certo para um servidor ou worker.

do-while

Um do-while executa o corpo uma vez antes de verificar a condição. Go não tem sintaxe própria para isso. Coloque a verificação no fim de um laço infinito:

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

O corpo executa pelo menos uma vez, aconteça o que acontecer, que é a propriedade que define o do-while. A fonte aleatória usa uma semente fixa para que a saída seja a mesma em toda execução; use rand.IntN sem uma fonte com semente para aleatoriedade de verdade.

Uma segunda forma mantém a condição no cabeçalho forçando a primeira passada:

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

Funciona, mas o laço infinito com um break no final é mais fácil de ler, e é o que a maior parte do código Go faz.

Lendo até acabar

O laço while mais comum em código Go real lê uma entrada até ela acabar. O bufio.Scanner foi feito para isso: Scan devolve false no fim da entrada ou em um erro, então ele é a condição do laço:

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

Troque strings.NewReader(input) por os.Stdin e o mesmo laço lê a entrada do usuário linha por linha. Verifique scanner.Err() depois do laço: Scan devolver false não diz se a entrada terminou normalmente ou falhou.

break e continue

Os dois funcionam em todas as formas 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()
}

Em um laço só com condição, o continue pula direto para a condição. Isso facilita um bug sutil: se o contador é atualizado no fim do corpo, um continue acima dele pula a atualização e o laço nunca termina. Atualize o contador no começo, como acima, ou use um for de três cláusulas, cuja instrução post executa mesmo depois de um continue.

Esperando por algo

Um laço que espera por uma condição deve bloquear ou dormir, não girar em vão:

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

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

Consultar repetidamente uma variável comum que outra goroutine escreve também é uma data race. Entre goroutines, espere em um channel, em um sync.WaitGroup ou em um sync.Cond, ou use select com um timer. Para laços de nova tentativa com limite, prefira um for contado, para que o laço não possa rodar para sempre:

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

Erros comuns

• Esquecer de mudar a variável da condição. for i < 10 { fmt.Println(i) } nunca termina. Todo laço while precisa de algo no corpo que o leve em direção à saída.
• Escrever while. while x < 5 {} dá syntax error: unexpected name x at end of statement, porque while não é palavra-chave; o compilador o lê como um nome comum.
• Parênteses por hábito. for (x < 5) {} compila, e o gofmt remove os parênteses.
• Declarar a variável no laço. for n := 10; n > 0 {} é erro de sintaxe; um laço com cláusula de inicialização precisa das três cláusulas. Declare n antes do laço ou escreva a forma completa de três cláusulas.

for count < 10 {
	count++
}

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