Escolha múltipla com switch ou case

Selecione um caminho a partir de valores discretos e trate casos, agrupamentos, término e alternativas sem correspondência.

Conteúdo 25 de 39Publicado em 10 de setembro de 202620 min de leituraSkills Tecnológicas

Seletor circular desenhado a lápis direciona uma forma de entrada para um entre quatro casos geométricos ou para o caminho padrão

`switch` e `case` organizam alternativas por valor

Uma seleção múltipla compara o resultado de uma expressão com casos previamente definidos. Quando encontra uma correspondência, executa o bloco associado. Se nenhum caso corresponder, pode seguir para um caso padrão.

Considere um sistema que decide a próxima ação a partir do estado de um pedido:

ESCOLHA statusPedido
  CASO "recebido":
    separar itens
  CASO "em_transporte":
    acompanhar entrega
  CASO "entregue":
    solicitar avaliação
  OUTRO CASO:
    encaminhar para análise
FIM ESCOLHA

O algoritmo avalia statusPedido uma vez e procura o caso correspondente. Com o valor "entregue", somente a ação “solicitar avaliação” deve ser executada. Um switch não repete a decisão: ele oferece uma forma estruturada de expressar vários resultados possíveis para o mesmo seletor.

Um valor de status entra em um seletor, é comparado com três casos nomeados e segue para uma ação correspondente ou para o caso padrão — O seletor é avaliado, um caso compatível recebe o fluxo e o caso padrão cobre valores sem correspondência.

Essa estrutura é uma especialização das estruturas condicionais: funciona melhor quando uma única informação pode assumir alternativas discretas e bem conhecidas.

A anatomia de uma seleção múltipla

Os nomes mudam entre linguagens, mas a estrutura costuma reunir cinco elementos:

seletor: expressão avaliada para obter o valor que será comparado;
caso: valor, rótulo ou padrão capaz de receber o fluxo;
bloco: instruções executadas quando há correspondência;
término: regra que encerra o caso ou impede a continuação indevida;
caso padrão: caminho para valores não contemplados.

Em JavaScript, o exemplo pode ser escrito assim:

switch (statusPedido) {
  case "recebido":
    separarItens();
    break;
  case "em_transporte":
    acompanharEntrega();
    break;
  case "entregue":
    solicitarAvaliacao();
    break;
  default:
    encaminharParaAnalise();
}

O switch recebe o seletor. Cada case define uma correspondência possível. default é o caminho sem correspondência e, nessa forma tradicional do JavaScript, break encerra o caso selecionado.

O caso padrão não precisa ocupar a última posição em todas as linguagens, mas mantê-lo no final costuma tornar a leitura previsível. Mais importante que a posição é decidir conscientemente o que fazer com valores inesperados.

Quando `switch` fica mais claro que `else if`

Uma cadeia pode expressar a mesma seleção:

SE statusPedido = "recebido" ENTÃO
  separar itens
SENÃO SE statusPedido = "em_transporte" ENTÃO
  acompanhar entrega
SENÃO SE statusPedido = "entregue" ENTÃO
  solicitar avaliação
SENÃO
  encaminhar para análise
FIM SE

O switch tende a comunicar melhor a intenção quando:

todos os ramos consultam o mesmo seletor;
as alternativas são valores discretos, como estados, comandos ou categorias;
somente um resultado deve ser escolhido;
os casos são estáveis e fáceis de enumerar.

Uma cadeia de else if continua adequada quando cada ramo faz uma pergunta diferente:

SE saldo < 0 ENTÃO
  situação <- "devedor"
SENÃO SE diasSemMovimento > 180 ENTÃO
  situação <- "inativo"
SENÃO SE possuiPendenciaCadastral ENTÃO
  situação <- "revisão"
SENÃO
  situação <- "regular"
FIM SE

Aqui não existe um único valor comparado com alternativas. Existem critérios heterogêneos, incluindo faixa numérica, tempo e estado lógico. Forçar um switch tradicional esconderia a regra ou exigiria truques.

Comparação mostra uma cadeia else if com perguntas diferentes e um switch que compara um único seletor com vários valores discretos — Use cadeia para perguntas diferentes; use seleção por casos quando o mesmo seletor é confrontado com alternativas discretas.

Não escolha pelo número de linhas. Escolha pela forma da regra: muitas perguntas favorecem a cadeia; uma pergunta com muitas respostas enumeráveis favorece a seleção por casos.

O caso padrão torna o domínio explícito

Se os estados válidos são recebido, em_transporte e entregue, o que significa receber "cancelado", uma string vazia ou um erro de digitação?

Existem três estratégias comuns:

executar um comportamento seguro;
registrar e rejeitar o valor inesperado;
não fazer nada, mas somente quando a ausência de ação fizer parte da regra.

Para o pedido, encaminhar o valor desconhecido para análise evita tratá-lo como um estado válido. Em uma rotina interna, falhar de forma explícita pode revelar um contrato quebrado:

OUTRO CASO:
  registrar "status não reconhecido"
  interromper processamento

O default não valida sozinho a entrada. Ele apenas define o comportamento quando não há correspondência. A próxima aula tratará validação de entradas e regras de negócio em profundidade.

Em um conjunto que deveria ser completo, o caso padrão também funciona como alarme de manutenção. Se um novo estado for criado e o seletor não for atualizado, o caminho padrão torna a omissão observável.

Casos diferentes podem compartilhar o mesmo bloco

Às vezes valores distintos levam à mesma ação. Um atendimento pode tratar sábado e domingo como fim de semana:

switch (diaSemana) {
  case "sábado":
  case "domingo":
    usarHorarioDeFimDeSemana();
    break;
  default:
    usarHorarioDeDiaUtil();
}

Os dois rótulos apontam para um único bloco. Isso evita duplicar a ação, mas exige entender a regra de continuidade da linguagem.

Em C#, vários rótulos também podem compartilhar uma seção:

switch (diaSemana)
{
    case "sábado":
    case "domingo":
        UsarHorarioDeFimDeSemana();
        break;
    default:
        UsarHorarioDeDiaUtil();
        break;
}

Agrupe somente valores semanticamente equivalentes naquele contexto. Se dois casos hoje fazem a mesma coisa por coincidência, mas representam regras diferentes, duplicar ou extrair uma função nomeada pode tornar uma futura mudança mais segura.

`break` e continuidade mudam entre linguagens

Em um switch tradicional do JavaScript, omitir break permite que a execução continue nas instruções do caso seguinte, mesmo que o rótulo seguinte não corresponda ao seletor. Esse comportamento é chamado fall-through.

switch (nivel) {
  case "administrador":
    permissoes.push("configurar");
    // sem break: continua no próximo bloco
  case "editor":
    permissoes.push("publicar");
    break;
  default:
    permissoes.push("visualizar");
}

Com nivel = "administrador", o algoritmo adiciona "configurar" e "publicar". Isso pode ser intencional, mas também pode ser um defeito silencioso. Se a intenção é somente agrupar rótulos, deixe casos vazios consecutivos e concentre as instruções no bloco compartilhado.

As linguagens não adotam uma regra única:

JavaScript: o switch tradicional continua para o próximo caso quando não encontra uma interrupção;
Java: rótulos tradicionais com : podem continuar; regras modernas com -> não sofrem fall-through;
C#: uma seção não vazia não pode simplesmente cair na próxima; ela precisa terminar, por exemplo, com break, return ou outra transferência válida;
Python: não possui switch; match executa somente o primeiro padrão correspondente.

Diagrama compara um caso encerrado por break com outro que continua acidentalmente para a ação seguinte, e resume as regras diferentes de JavaScript, Java moderno, C Sharp e Python — `break` encerra o caso na forma tradicional; outras sintaxes impedem ou redefinem a continuidade.

Ao mudar de linguagem, não transporte mecanicamente a sintaxe. Consulte as regras de seleção e término daquela linguagem.

`switch` moderno e `match` podem fazer mais que igualdade simples

Para aprender a ideia transferível, comece pela comparação de valores discretos. Algumas linguagens modernas ampliam esse modelo.

Java oferece expressões switch capazes de produzir um valor e regras com seta:

String acao = switch (statusPedido) {
    case "recebido" -> "separar";
    case "em_transporte" -> "acompanhar";
    case "entregue" -> "avaliar";
    default -> "analisar";
};

Python usa casamento de padrões com match e case:

match status_pedido:
    case "recebido":
        separar_itens()
    case "em_transporte":
        acompanhar_entrega()
    case "entregue":
        solicitar_avaliacao()
    case _:
        encaminhar_para_analise()

O _ atua como curinga no exemplo. O match pode decompor sequências e objetos, associar partes a nomes e usar condições adicionais. Por isso, ele é mais poderoso que um switch baseado apenas em igualdade.

Em C#, padrões também permitem selecionar por tipo, propriedade e condições. Nessas formas avançadas, a ordem pode se tornar relevante porque padrões mais específicos e mais gerais podem se sobrepor. Não presuma que todas as construções chamadas switch, case ou match possuem exatamente a mesma semântica.

Separe a escolha da ação quando a tabela crescer

Um switch muito grande pode concentrar responsabilidades demais. Se cada caso apenas associa uma chave a um dado, um mapa ou dicionário pode ser mais direto:

mensagemPorStatus <- {
  "recebido": "Pedido recebido",
  "em_transporte": "Pedido a caminho",
  "entregue": "Pedido entregue"
}

Essa alternativa é adequada quando os casos formam uma tabela de consulta sem lógica própria. Um switch continua útil quando cada ramo executa um pequeno comportamento diferente e a seleção pertence claramente àquele ponto do fluxo.

Considere dividir a solução quando:

dezenas de casos dificultam localizar a regra;
cada caso contém muitas etapas;
o mesmo seletor aparece em vários switch espalhados;
novos casos exigem alterar muitas partes do sistema;
os ramos dependem de serviços ou dados que deveriam ter responsabilidades separadas.

Não transforme antecipadamente um seletor pequeno em uma arquitetura complexa. Primeiro preserve clareza e testes; extraia responsabilidades quando o crescimento real tornar a estrutura difícil de manter.

Teste cada caso e também o que ficou de fora

Para o exemplo de pedidos, uma tabela mínima é:

Entrada	Caso esperado	Ação esperada
`"recebido"`	recebido	separar itens
`"em_transporte"`	em transporte	acompanhar entrega
`"entregue"`	entregue	solicitar avaliação
`"cancelado"`	padrão	encaminhar para análise
`""`	padrão	encaminhar para análise

Execute um teste de mesa e registre:

valor produzido pelo seletor;
caso que recebeu o fluxo;
instruções executadas;
ponto em que a seleção terminou;
continuação após o switch.

Quando existir agrupamento, teste ao menos um valor de cada rótulo compartilhado. Quando a linguagem permitir fall-through, verifique que nenhum bloco seguinte foi executado por engano. Se a seleção produz um valor, confirme que todos os caminhos possíveis produzem um resultado compatível.

Erros comuns

Usar `switch` para intervalos em uma linguagem baseada em igualdade

Casos como “idade menor que 18” e “saldo maior que 1000” são condições, não valores discretos. Uma cadeia costuma representar melhor essas faixas.

Repetir seletores diferentes entre os casos

Se cada ramo depende de uma variável diferente, a estrutura já não comunica uma escolha sobre um único domínio. Reavalie com else if ou decomponha a regra.

Esquecer o comportamento sem correspondência

Sem caso padrão, um valor inesperado pode atravessar a seleção sem produzir ação. Decida e teste explicitamente esse caminho.

Omitir `break` por acidente

Em linguagens que aceitam continuidade, o caso seguinte pode executar. Use a forma idiomática da linguagem e deixe qualquer fall-through intencional evidente.

Duplicar o mesmo bloco em vários casos

Agrupe rótulos quando eles realmente representam a mesma regra ou extraia uma ação nomeada.

Supor que `switch` e `match` são sinônimos

Comparação de constantes, padrões, guardas, produção de valores e regras de término variam. A documentação da linguagem é parte do contrato.

Pratique com comandos de atendimento

Um terminal aceita estes comandos:

"novo": abrir atendimento;
"consultar" ou "buscar": localizar atendimento;
"encerrar": finalizar atendimento;
qualquer outro valor: informar comando inválido.

Escreva a seleção em pseudocódigo e depois em uma linguagem que você conhece. Agrupe "consultar" e "buscar" sem duplicar a ação.

Teste os cinco valores "novo", "consultar", "buscar", "encerrar" e "editar". Para cada um, anote o caso alcançado e confirme que apenas uma ação foi executada. Se usar JavaScript ou a sintaxe tradicional de Java, retire temporariamente um break, observe a diferença e restaure o término correto.

O que você deve guardar

switch ou case organiza uma escolha quando um seletor pode corresponder a alternativas discretas. Cada caso associa um valor ou padrão a um bloco, enquanto o caso padrão define o comportamento para o que não foi previsto.

Prefira uma cadeia quando os ramos fazem perguntas diferentes, trate o término conforme a linguagem e teste cada caso, os agrupamentos e o caminho sem correspondência. Recursos modernos como expressões switch e match ampliam a ideia, mas também possuem regras próprias. Em seguida, aprenda como validar entradas e regras de negócio antes de permitir que dados inadequados percorram o algoritmo.

Referências

MDN Web Docs — switch em JavaScript. Acesso em 10 set. 2026.
Microsoft Learn — Selection statements em C#. Acesso em 10 set. 2026.
Python Documentation — A instrução match. Acesso em 10 set. 2026.
Oracle — Switch expressions and statements em Java. Acesso em 10 set. 2026.

switch e case organizam alternativas por valor