Noções Básicas de Fluxo de Controle

10 exemplos para você começar com Fluxo de Controle - 7 básicos e 3 intermediários.

Pré-requisitos

• Instale Go 1.26.x ou posterior em go.dev/dl.
• Crie um módulo: mkdir flow && cd flow && go mod init example.com/flow.
• Salve cada trecho como main.go e execute com go run ..

Exemplos Básicos

1. if / else

Ramifica com base em uma condição booleana.

package main
 
import "fmt"
 
func main() {
    n := 7
    if n%2 == 0 {
        fmt.Println("par")
    } else {
        fmt.Println("ímpar")
    }
}

• if não precisa de parênteses em torno da condição.
• Chaves são obrigatórias - Go impõe a estrutura de blocos em tempo de compilação.
• A condição deve ser uma expressão booleana, não um valor "truthy".

Relacionado: if com Inicialização e Padrões de switch - cláusulas init e formas de switch

2. Loop for estilo C

O cabeçalho clássico de três partes: init, condição, pós.

package main
 
import "fmt"
 
func main() {
    sum := 0
    for i := 0; i < 5; i++ {
        sum += i
    }
    fmt.Println(sum) // 10
}

• Go não tem uma palavra-chave while separada - esta é a única palavra-chave de loop.
• A variável de inicialização i tem escopo para a instrução for.
• Omita init e post para outras formas de for mostradas em exemplos posteriores.

Relacionado: Variantes de Loop for e Semântica de range - todas as formas de for

3. for range em um slice

Itera índice e valor juntos.

package main
 
import "fmt"
 
func main() {
    langs := []string{"Go", "Rust", "Zig"}
    for i, name := range langs {
        fmt.Println(i, name)
    }
}

• range funciona em slices, arrays, mapas, canais e strings.
• Use _ para ignorar índice ou valor: for _, name := range langs.
• Modificar elementos através da variável de valor do range não atualiza o slice (use o índice).

Relacionado: Variantes de Loop for e Semântica de range - semântica por coleção

4. switch de Expressão

Compara um valor contra múltiplos casos.

package main
 
import "fmt"
 
func main() {
    day := "Seg"
    switch day {
    case "Sab", "Dom":
        fmt.Println("fim de semana")
    default:
        fmt.Println("dia de semana")
    }
}

• Casos não caem automaticamente (diferente de C).
• Múltiplos valores podem compartilhar um caso com vírgulas.
• default é executado quando nenhum caso corresponde.

Relacionado: if com Inicialização e Padrões de switch - switch sem tags e de tipo

5. if com instrução init

Associa uma variável temporária com escopo para o bloco if.

package main
 
import (
    "fmt"
    "strconv"
)
 
func main() {
    if n, err := strconv.Atoi("42"); err != nil {
        fmt.Println("erro de parse:", err)
    } else {
        fmt.Println("parseado:", n)
    }
}

• A instrução init é executada uma vez antes da condição.
• Variáveis do init são visíveis apenas nos blocos if e else.
• Este padrão é a verificação de erro idiomática em Go.

Relacionado: Design Orientado a Expressões de Fluxo de Controle em Go - por que as cláusulas init importam

6. defer para limpeza

Agenda uma chamada para ser executada quando a função retornar.

package main
 
import "fmt"
 
func main() {
    defer fmt.Println("limpeza")
    fmt.Println("trabalho")
}

• Chamadas adiadas são executadas em ordem LIFO (last-in, first-out).
• defer é executado na saída da função, incluindo o desenrolar do panic.
• Emparelhe defer f.Close() imediatamente após um Open() bem-sucedido.

Relacionado: defer, panic & recover - pilha de defer e recuperação

7. break e continue

Pula uma iteração ou sai do loop prematuramente.

package main
 
import "fmt"
 
func main() {
    for i := 0; i < 10; i++ {
        if i%2 == 0 {
            continue
        }
        if i > 5 {
            break
        }
        fmt.Println(i)
    }
}

• continue salta para a próxima iteração.
• break sai do for, switch ou select mais interno.
• Rótulos estendem break/continue para loops externos (veja o exemplo intermediário).

Relacionado: break, continue & Fluxo de Controle Rotulado - saídas rotuladas

Exemplos Intermediários

8. switch de Tipo em interface{}

Ramifica com base no tipo dinâmico dentro de um valor de interface.

package main
 
import "fmt"
 
func describe(v any) {
    switch x := v.(type) {
    case int:
        fmt.Println("int", x)
    case string:
        fmt.Println("string", x)
    default:
        fmt.Printf("outro %T\n", x)
    }
}
 
func main() {
    describe(42)
    describe("oi")
}

• v.(type) só é permitido em uma instrução switch.
• A variável curta x contém o valor tipado em cada caso.
• Prefira funções tipadas em vez de any quando o conjunto de tipos for conhecido.

Relacionado: if com Inicialização e Padrões de switch - padrões de type switch

9. break Rotulado de loops aninhados

Sai de um loop externo sem uma flag auxiliar.

package main
 
import "fmt"
 
func main() {
outer:
    for i := 0; i < 3; i++ {
        for j := 0; j < 3; j++ {
            if i*j == 4 {
                break outer
            }
            fmt.Println(i, j)
        }
    }
}

• O rótulo deve estar em uma instrução for, switch ou select.
• continue outer salta para a próxima iteração do loop rotulado.
• Extraia uma função quando os rótulos tornarem o fluxo difícil de seguir.

Relacionado: break, continue & Fluxo de Controle Rotulado - quando os rótulos ajudam

10. panic e recover

Recover para o desenrolar do panic dentro de uma função deferida.

package main
 
import "fmt"
 
func mayPanic() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("recuperado:", r)
        }
    }()
    panic("boom")
}
 
func main() {
    mayPanic()
    fmt.Println("main continua")
}

• recover retorna nil a menos que seja chamado de uma função deferida durante um panic.
• Erros normais devem retornar error, não entrar em panic.
• Servidores HTTP usam este padrão em middleware para evitar travar o processo.

Relacionado: Fluxo de Controle em Middleware HTTP - manipuladores seguros contra panic

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