break, continue & Fluxo de Controle Rotulado

break e continue ajustam o fluxo de loop e select, enquanto os rótulos permitem que você direcione um for, switch ou select externo quando a lógica aninhada, de outra forma, precisaria de flags ou condições duplicadas.

Usados com moderação, os rótulos esclarecem a intenção; usados em excesso, obscurecem a estrutura.

Resumo

break sai do for, switch ou select mais interno.

continue pula para a próxima iteração do loop mais interno.

Um rótulo em um loop ou select permite que break label ou continue label direcionem essa instrução.

break dentro de select sai apenas do select, não do loop circundante, a menos que rotulado.

Refatorar para uma função auxiliar geralmente é mais claro do que rótulos profundos.

Receita

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

package main
 
import "fmt"
 
func main() {
    for i := 0; i < 5; i++ {
        if i == 2 {
            continue // pula a impressão de 2
        }
        if i == 4 {
            break // para antes de 4
        }
        fmt.Println(i)
    }
}

Quando usar isso:

• Use continue para pular iterações irrelevantes sem aninhar outro corpo if.
• Use break quando iterações adicionais não puderem alterar o resultado (alvo encontrado, erro).
• Use break rotulado para sair de uma busca em loops aninhados sem booleanos found.
• Extraia uma função quando mais de um rótulo ou múltiplas saídas tornarem o fluxo difícil de escanear.

Exemplo de Trabalho

package main
 
import (
    "fmt"
    "time"
)
 
func findPair(matrix [][]int, target int) (int, int, bool) {
search:
    for r, row := range matrix {
        for c, v := range row {
            if v == target {
                return r, c, true
            }
            if v < 0 {
                break search // aborta toda a busca em sentinela
            }
        }
    }
    return 0, 0, false
}
 
func poll(ctxDone <-chan struct{}) {
    ticker := time.NewTicker(100 * time.Millisecond)
    defer ticker.Stop()
 
loop:
    for {
        select {
        case <-ctxDone:
            break loop // sai do for, não apenas do select
        case <-ticker.C:
            fmt.Println("tick")
        }
    }
    fmt.Println("stopped")
}
 
func main() {
    m := [][]int{{1, 2}, {-1, 9}, {3, 4}}
    r, c, ok := findPair(m, 9)
    fmt.Println("found", r, c, ok)
 
    done := make(chan struct{})
    go func() {
        time.Sleep(250 * time.Millisecond)
        close(done)
    }()
    poll(done)
}

O que isso demonstra:

• break search rotulado sai de loops aninhados em um valor sentinela.
• Retornar (r, c, true) é uma alternativa ao break rotulado quando os resultados são necessários.
• break loop em um select dentro de for sai do loop externo, não apenas do select.
• continue não é mostrado aqui, mas pularia para a próxima iteração do ticker de forma semelhante.

Mergulho Profundo

Como Funciona

• break e continue se aplicam à construção ativa mais interna de seu tipo.
• Rótulos devem ser anexados a uma instrução for, switch ou select - não a blocos arbitrários.
• goto existe em Go, mas é desencorajado, exceto em raríssimos geradores de código e otimizações de baixo nível.
• return sai da função inteira, o que muitas vezes substitui breaks rotulados em helpers.
• select com default mais break pode criar um loop ocupado se você esquecer de bloquear ou dormir.

break vs continue vs return

Padrão select + for

for {
    select {
    case <-ctx.Done():
        break loop   // sai do for, não apenas do select
    case v := <-ch:
        handle(v)
    }
}

Sem o rótulo, break sairia apenas do select e imediatamente reentraria no for.

Notas de Go

// Prefira retorno antecipado em vez de break rotulado ao calcular um resultado
func contains(haystack []string, needle string) bool {
    for _, s := range haystack {
        if s == needle {
            return true
        }
    }
    return false
}

Armadilhas

• break sai apenas do select - for { select { case <-done: break } } entra em loop infinito. Correção: use break loop com um rótulo no for, ou return.
• continue rotulado em switch - continue visa apenas loops, não switch. Correção: reestruture ou use return.
• Variáveis de flag em vez de rótulos - booleanos found com múltiplos níveis de break confundem os leitores. Correção: rotule uma vez ou extraia uma função.
• continue pula a lógica de atraso - Colocar continue antes do rate limiting causa loops apertados. Correção: coloque o throttling após a verificação de continue ou no final do loop.
• Saindo de defer - break não cruza limites de função. Correção: use return do helper.
• goto como substituto - Saltos sem rótulo prejudicam a legibilidade. Correção: prefira fluxo de controle estruturado e funções.

Alternativas

FAQs

Relacionados

• Variantes de Loop for & Semântica de range - loops dos quais você sai
• Noções Básicas de Fluxo de Controle - introdução a break/continue
• Fluxo de Controle Go: Design Orientado a Expressões - orientação de fluxo plano
• Armadilhas de Reutilização de Variável de range - closures dentro de loops que você pode continuar
• Melhores Práticas de Fluxo de Controle - reestruture lógica aninhada

Versões de Stack: Esta página foi escrita para Go 1.26.x (padrão GC Green Tea, 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).

NzA2MjAyfDg5M29pZ2N8b2kuc2VkaXVnZWRvYw==