if com Inicialização e Padrões de switch

O Go aprimora o código condicional permitindo que if e switch executem uma instrução de inicialização única antes do branch, e oferecendo switches de valor e switches de tipo em interfaces.

Dominar essas formas mantém o tratamento de erros plano e substitui longas cadeias de if/else por discriminação mais clara.

Resumo

Uma instrução de inicialização em if ou switch escopa variáveis temporárias para o bloco.

Switches de expressão comparam um valor contra casos sem fallthrough implícito.

Switches sem tag encadeiam casos booleanos como else if.

Switches de tipo inspecionam tipos dinâmicos dentro de interfaces.

fallthrough é explícito e incomum.

Receita

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

package main
 
import (
    "fmt"
    "os"
)
 
func main() {
    // Abre um arquivo e trata o erro imediatamente.
    if f, err := os.Open("config.txt"); err != nil {
        fmt.Println(err)
        return
    } else {
        // Garante que o arquivo seja fechado quando a função retornar.
        defer f.Close()
        fmt.Println("aberto", f.Name())
    }
 
    code := 404
    // Switch de valor compara 'code' com constantes.
    switch code {
    case 200:
        fmt.Println("ok")
    case 404:
        fmt.Println("não encontrado")
    default:
        fmt.Println("outro")
    }
}

Quando usar isso:

• Use if err := ...; err != nil imediatamente após chamadas que retornam erros.
• Use switch de valor ao comparar uma expressão com muitas constantes.
• Use switch true sem tag (ou condições nuas) para casos booleanos ordenados.
• Use switches de tipo quando o comportamento depende do tipo concreto dentro de uma interface{} ou restrição genérica.

Exemplo de Trabalho

package main
 
import (
    "encoding/json"
    "fmt"
)
 
// Event representa um evento com um tipo e um payload.
type Event struct {
    Kind string
    Payload any
}
 
// handle processa um evento com base no tipo de seu payload.
func handle(e Event) error {
    // Type switch para inspecionar o tipo dinâmico do payload.
    switch p := e.Payload.(type) {
    case nil:
        return fmt.Errorf("payload ausente para %s", e.Kind)
    case json.RawMessage:
        fmt.Println("bytes json brutos", len(p))
    case map[string]any:
        fmt.Println("chaves do objeto", len(p))
    case string:
        fmt.Println("string", p)
    default:
        // Lida com tipos de payload inesperados.
        return fmt.Errorf("payload não suportado %T", p)
    }
    return nil
}
 
// classify retorna uma letra de nota com base em uma pontuação.
func classify(score int) string {
    // Switch sem tag encadeia condições booleanas.
    switch {
    case score >= 90:
        return "A"
    case score >= 80:
        return "B"
    default:
        return "C"
    }
}
 
func main() {
    events := []Event{
        {Kind: "text", Payload: "hello"},
        {Kind: "obj", Payload: map[string]any{"k": 1}},
    }
    for _, e := range events {
        // Verifica erros após cada chamada de handle.
        if err := handle(e); err != nil {
            fmt.Println(err)
        }
    }
    fmt.Println(classify(85))
}

O que isso demonstra:

• Type switch com p := e.Payload.(type) vincula uma variável tipada por caso.
• default lida com tipos dinâmicos inesperados com %T em erros.
• Switch sem tag com nenhuma expressão de tag encadeia comparações como if/else if.
• Verificações de erro permanecem no local da chamada com tratamento antecipado no loop.

Mergulho Profundo

Como Funciona

• A inicialização é executada uma vez antes da condição; variáveis declaradas na inicialização são escopadas para o if/switch.
• Switches de valor avaliam os casos de cima para baixo; o primeiro caso verdadeiro é executado e, em seguida, sai, a menos que fallthrough apareça.
• Type switches exigem que o operando seja uma interface; cada caso deve atender às regras de atribuibilidade da interface.
• Switches sem tag avaliam casos como expressões booleanas em ordem - úteis para intervalos e condições compostas.
• switch pode incluir uma instrução de inicialização: switch err := f(); err != nil { case ... } (incomum, mas válido).

Formas de Switch em Resumo

Regras de fallthrough

Notas do Go

// Type assert com vírgula-ok no if - alternativa ao type switch para um tipo
if s, ok := v.(string); ok {
    fmt.Println(s)
}
 
// switch em strings com casos duplicados é um erro de compilação
// correspondência insensível a maiúsculas/minúsculas: normalize antes do switch ou use switch sem tag

Armadilhas

• Vazamento de variáveis de inicialização - Usar err após o bloco if quando declarado na inicialização. Correção: mantenha o tratamento dentro do bloco ou declare err fora intencionalmente.
• Assumir fallthrough no switch - A falta de break (bugs do C) não se aplica, mas fallthrough acidental causa execução dupla. Correção: remova fallthrough, a menos que seja deliberado.
• Type switch em não-interface - x.(type) só funciona em operandos de interface. Correção: passe any ou um pequeno wrapper de interface.
• Interface nil vs ponteiro nil tipado - switch v := i.(type) { case *T: } pode corresponder a um ponteiro nil tipado. Correção: verifique v == nil dentro do caso.
• Expressões de caso duplicadas - Erro de compilação se dois casos se sobrepuserem em valores. Correção: combine com listas de vírgulas case 1, 2:.
• Ordem do switch sem tag importa - O primeiro caso verdadeiro vence; coloque condições mais específicas primeiro.

Alternativas

FAQs

Relacionados

• Noções Básicas de Fluxo de Controle - primeiros snippets de if e switch
• Fluxo de Controle do Go: Design Orientado a Expressões - modelo mental orientado a expressões
• defer, panic & recover - pareando defer com aberturas bem-sucedidas de if
• Interface Nil vs Ponteiro Nil - nil tipado em type switches
• Noções Básicas de Tratamento de Erros - verificações de erro ao lado de if estilo init

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