Variantes do Loop for & Semântica do range

O Go expressa todo loop com for, mas a forma que você escolhe muda o que você copia, o que você pode mutar e quando o loop para.

Esta página mapeia cada variante de for para as coleções e canais que você verá em código de produção.

Resumo

O cabeçalho for de três partes cobre loops contados.

A forma apenas com condição age como while.

for range percorre slices, arrays, mapas, canais e strings com significado de índice/valor específico do tipo.

Canais bloqueiam até que um valor chegue ou o canal feche.

Mapas iteram em ordem aleatória.

Strings retornam deslocamentos de bytes e runas, não bytes diretamente.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

package main
 
import "fmt"
 
func main() {
    // Estilo C
    for i := 0; i < 3; i++ {
        fmt.Println("count", i)
    }
 
    // Estilo while
    n := 3
    for n > 0 {
        n--
    }
 
    // range slice
    for i, v := range []int{10, 20} {
        fmt.Println(i, v)
    }
}

Quando usar isso:

• Use for de três partes quando precisar de um contador de índice com uma condição final clara.
• Use for apenas com condição para loops de eventos, novas tentativas e bombas de canal (for { select { ... } }).
• Use for range para iteração idiomática sobre coleções e canais abertos.
• Use for range em vez de alternativas 1..n via slices ou for i := 0; i < n; i++ - Go não tem operador de intervalo inclusivo.

Exemplo de Trabalho

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    // Slice: mutar por índice
    nums := []int{1, 2, 3}
    for i := range nums {
        nums[i] *= 2
    }
    fmt.Println("slice", nums)
 
    // Map: chaves e valores (ordem varia a cada execução)
    m := map[string]int{"a": 1, "b": 2}
    for k, v := range m {
        fmt.Println("map", k, v)
    }
 
    // Canal: receber até fechar
    ch := make(chan int, 2)
    ch <- 1
    ch <- 2
    close(ch)
    for v := range ch {
        fmt.Println("chan", v)
    }
 
    // String: índice de byte e runa
    for i, r := range "Go🙂" {
        fmt.Printf("string i=%d r=%U\n", i, r)
    }
 
    // Loop infinito com break por timeout
    deadline := time.Now().Add(50 * time.Millisecond)
    for {
        if time.Now().After(deadline) {
            break
        }
    }
    fmt.Println("done")
}

O que isso demonstra:

• A mutação de slice requer acesso por índice, não a cópia do valor do range.
• A ordem de iteração de mapas não é estável - nunca dependa dela.
• for range em um canal termina quando o canal é fechado e todos os valores em buffer são recebidos.
• O range de string decodifica runas UTF-8; o índice salta pela largura em bytes para caracteres multibyte.
• Loops infinitos apenas com condição combinam-se com break, return ou select.

Mergulho Profundo

Como Funciona

• for cria um escopo de bloco; a variável de inicialização em um loop de três partes tem escopo para a instrução for.
• range avalia a coleção uma vez; para arrays/slices, ele copia o cabeçalho, não os elementos do array de suporte.
• A recepção de canal em for range bloqueia até que um valor esteja pronto; o padrão de valor zero mais ok é implícito na forma de range.
• Iteradores de mapa escolhem buckets de início aleatórios - a ordem difere entre processos e execuções por design.
• O range de string converte bytes em runas; len(s) é o comprimento em bytes, que difere da contagem de runas.

range por Tipo

Formas do Loop for

Notas Go

// Omita valor ou índice com o identificador em branco
for _, v := range items { _ = v }
for i := range items { _ = i }
 
// range sobre array copia elementos para a forma de valor em arrays grandes - use índice
var big [10000]byte
for i := range big {
    big[i] = 1
}

Armadilhas

• Mutar elementos de slice via valor do range - for _, v := range s { v = 1 } atualiza uma cópia. Correção: use índice: for i := range s { s[i] = 1 }.
• Depender da ordem de iteração do mapa - Testes que assumem a ordem das chaves falham. Correção: ordene as chaves primeiro ou compare multiconjuntos.
• Iterar sobre um canal aberto para sempre - Sem fechar, for range ch bloqueia para sempre. Correção: feche do lado do remetente ou use select com ctx.Done().
• Confundir comprimento da string com contagem de runas - len("é") são 2 bytes em UTF-8. Correção: use range ou utf8.RuneCountInString.
• Cópias de range de arrays grandes - Iterar sobre o valor do array copia cada elemento. Correção: itere índices em arrays ou use slices.
• Erro de um a mais com loops de três partes - Usar <= quando < era a intenção. Correção: prefira os idiomas for i := 0; i < len(s); i++.

Alternativas

FAQs

Relacionados

• Noções Básicas de Controle de Fluxo - trechos introdutórios para for e range
• break, continue & Controle de Fluxo Rotulado - saindo de loops aninhados
• Armadilhas de Reutilização de Variável de Range - captura de closure em loops
• Controle de Fluxo em Go: Design Orientado a Expressões - visão geral conceitual
• Arrays, Slices e Mapas em Resumo - tipos de coleção iterados aqui

Versões de Stack: Esta página foi escrita para Go 1.26.x (padrão Green Tea GC, go fix modernizers - verifique o patch na compilação), chi (última - verifique na compilação), gin (última - verifique na compilação), echo (última - verifique na compilação), google.golang.org/grpc (última - verifique na compilação), sigs.k8s.io/controller-runtime (última - verifique na compilação), kubebuilder (última - verifique na compilação), tinygo (última - verifique os alvos de placa na compilação), wazero (última - verifique na compilação) e golangci-lint (última - verifique o conjunto de linters na compilação).