Go Academy · Aula

Instruções switch em Go

switch com e sem tag e fallthrough

Aula 3 de 412 etapas

Instruções switch em Go é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Noções básicas de switch

O switch do Go é mais poderoso do que em C: não há passagem automática para o próximo case por padrão, e os cases podem ter vários valores:

day := "Monday"
switch day {
case "Saturday", "Sunday":
    fmt.Println("Weekend")
default:
    fmt.Println("Weekday")
}

Sem passagem implícita para o próximo case

Em Go, o corpo de cada case é encerrado automaticamente — ao contrário de C, onde é preciso escrever break explicitamente:

Código mais claro e menos bugs
Use fallthrough explicitamente quando precisar desse comportamento semelhante ao de C (raramente necessário)

switch com instrução de inicialização

Assim como if, switch aceita uma instrução de inicialização opcional:

switch os := runtime.GOOS; os {
case "linux":
    fmt.Println("Linux")
case "darwin":
    fmt.Println("macOS")
default:
    fmt.Printf("Other: %s\n", os)
}

switch sem expressão (alternativa à cadeia de if-else)

Um switch sem expressão não tem uma expressão após a palavra-chave — cada case avalia um booleano:

score := 75
switch {
case score >= 90:
    fmt.Println("A")
case score >= 80:
    fmt.Println("B")
case score >= 70:
    fmt.Println("C")
default:
    fmt.Println("F")
}

switch de tipos

Um switch de tipos inspeciona o tipo dinâmico de um valor de interface:

func describe(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("int: %d\n", v)
    case string:
        fmt.Printf("string: %s\n", v)
    default:
        fmt.Printf("unknown: %T\n", v)
    }
}

fallthrough

Use fallthrough para executar explicitamente o corpo do case seguinte, independentemente da condição dele (raramente necessário):

n := 1
switch n {
case 1:
    fmt.Println("one")
    fallthrough
case 2:
    fmt.Println("one or two")
}

Vários valores por case

Liste vários valores separados por vírgulas em um único case:

func isVowel(c byte) bool {
    switch c {
    case 'a', 'e', 'i', 'o', 'u':
        return true
    }
    return false
}

switch versus if-else

Use switch quando:

Você estiver comparando uma expressão com muitos valores
Houver um switch de tipos para despacho de interfaces
A legibilidade melhorar em comparação com uma cadeia de if-else

Use if-else quando as condições forem expressões booleanas diferentes.

break em switch

Para sair de um switch antecipadamente, use break. Para sair de um laço externo a partir de dentro de um switch, use um break com rótulo:

loop:
for {
    switch input() {
    case "quit":
        break loop  // exits the for loop
    }
}

Caso default

O caso default é executado quando nenhum outro case corresponde. Práticas recomendadas:

Sempre inclua default ao tratar enumerações — para capturar valores inesperados
Coloque-o no final para melhorar a legibilidade
Em switches de tipos, use default para tratar tipos incompatíveis de forma adequada

Verificação rápida

O que acontece em Go quando um case de switch corresponde — a execução continua no case seguinte?

Responda na aula interativa

Recapitulação: switch em Go

O switch do Go é claro e poderoso:

Não há passagem automática para o próximo case — use fallthrough explicitamente
Instrução de inicialização para limitar o escopo de valores temporários
Switch sem expressão como alternativa a uma cadeia de if-else
Switch de tipos para despacho de interfaces
Vários valores por case, separados por vírgulas

Próximo: controle de laços com break, continue e rótulos.

Grátis para começar

Aprenda Go com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 51
Aulas: 203

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Instruções switch em Go” é grátis?

Sim — o texto completo de “Instruções switch em Go” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Instruções switch em Go”?

switch com e sem tag e fallthrough Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Instruções switch em Go”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Instruções if e expressões de inicialização
O laço for: todos os padrões
Instruções switch em Go
break, continue e rótulos

← Voltar para Go Academy