Switch JavaScript: O que é e como usar?

No contexto da programação, o comando “Switch” JavaScript é um mecanismo crucial para a tomada de decisões condicionais. Funcionando como uma ferramenta flexível, ele se adequa a múltiplos cenários, simplificando a gestão de decisões através de uma sintaxe limpa e eficiente. 

Sua capacidade de lidar com variados tipos de dados o torna essencial para desenvolvimento web e criação de jogos interativos. 

Este artigo, portanto, detalhará sua funcionalidade e aplicação, delimitando sua importância e versatilidade para adaptar-se às demandas específicas de um projeto.

O que é o Switch JavaScript?

A instrução switch avalia uma expressão. Ela compara o valor da expressão com uma série de cláusulas case. Quando encontra um valor correspondente, executa as instruções subsequentes, a menos que se encontre uma instrução break. Ignora-se a cláusula padrão se nenhum case coincidir com o valor da expressão. Por exemplo:

Sintaxe Básica

A sintaxe básica do switch em JavaScript:

switch (expressao) {

    case valor1:

        // código a ser executado se expressao === valor1

        break;

    case valor2:

        // código a ser executado se expressao === valor2

        break;

    // ... mais casos

    default:

        // código a ser executado se nenhum caso corresponder

}

Expressão

Uma expressão cujo resultado compara-se com cada cláusula case.

Valor do case N

Uma cláusula case usada para corresponder à expressão. Se a expressão corresponder ao valorN especificado (que pode ser qualquer expressão), a execução começará a partir da primeira instrução após a cláusula case até o final da instrução switch ou o primeiro break encontrado.

Default

Uma cláusula padrão, se fornecida, será executada se o valor da expressão não corresponder a nenhuma das cláusulas case. Dessa maneira, uma instrução switch só pode ter uma cláusula padrão.

A seguir um exemplo mais prático:

const diaDaSemana = "quarta";

switch (diaDaSemana) {

    case "segunda":

        console.log("Hoje é segunda-feira.");

        break;

    case "quarta":

        console.log("Hoje é quarta-feira.");

        break;

    // ...

    default:

        console.log("Dia não reconhecido.");

}

Exemplos profissionais

Tradução de Idioma

function traduzirMensagem(mensagem, idioma) {

    switch (idioma) {

        case "en":

            return traduçãoParaIngles(mensagem);

        case "fr":

            return traduçãoParaFrances(mensagem);

        case "es":

            return traduçãoParaEspanhol(mensagem);

        default:

            return mensagem; // Manter a mensagem original se o idioma não for suportado

    }

}

A função traduzirMensagem usa um switch para traduzir mensagens para diferentes idiomas com base no código de idioma fornecido. Assim, isso é útil em aplicativos multilíngues.

Controle de Acesso de Usuários

function verificarAcessoUsuario(usuario) {

    switch (usuario.tipo) {

        case "administrador":

            exibirPainelAdmin();

            break;

        case "cliente":

            exibirPainelCliente();

            break;

        case "convidado":

            exibirMensagemAcessoRestrito();

            break;

        default:

            exibirMensagemErroAcesso();

            break;

    }

}

A função acima usa um switch para determinar o tipo de usuário e conceder acesso a recursos apropriados com base nessa informação, como exibir um painel de administração ou uma mensagem de acesso restrito.

Avaliação de Desempenho de Estudantes

function avaliarDesempenhoAluno(nota) {

    switch (true) {

        case nota >= 90:

            return "A+";

        case nota >= 80:

            return "A";

        case nota >= 70:

            return "B";

        case nota >= 60:

            return "C";

        default:

            return "F";

    }

}

A função acima usa um switch com expressões booleanas para determinar a nota de um aluno com base em sua pontuação, esse exemplo também é uma questão popular para quem está iniciando um ensino superior, a seguir como implementar esse switch em um código completo para executar.

<div id="resultado">

        <!-- O resultado será exibido aqui -->

    </div>

    <script>

        function avaliarDesempenhoAluno(nota) {

            switch (true) {

                case nota >= 90:

                    return "A+";

                case nota >= 80:

                    return "A";

                case nota >= 70:

                    return "B";

                case nota >= 60:

                    return "C";

                default:

                    return "F";

            }

        }

        // Array com nomes e notas dos alunos

        const alunos = [

            { nome: "Alice", nota: 92 },

            { nome: "Bob", nota: 78 },

            { nome: "Carol", nota: 88 },

            { nome: "David", nota: 65 },

            { nome: "Eva", nota: 72 },

        ];

        // Elemento onde exibiremos o resultado

        const resultadoDiv = document.getElementById("resultado");

        // Loop para avaliar e exibir o desempenho de cada aluno

        for (let i = 0; i < alunos.length; i++) {

            const aluno = alunos[i];

            const desempenho = avaliarDesempenhoAluno(aluno.nota);

            resultadoDiv.innerHTML += `<p>Aluno ${i + 1}: ${aluno.nome}, Nota: ${aluno.nota}, Desempenho: ${desempenho}</p>`;

        }

    </script>

Portabilidade

Uma situação onde você tem um programa com dezenas a centenas de declarações if-else. Suponha que você esteja construindo um sistema de gerenciamento de pedidos para um restaurante online, e você precisa determinar qual ação executar com base em diferentes estados do pedido.

Cada estado pode corresponder a uma série de verificações if-else. Vejamos um exemplo simplificado:

// Exemplo de dezenas a centenas de declarações if-else

function processarPedido(estado) {

    if (estado === "novo") {

        // Lógica para processar um pedido novo

    } else if (estado === "preparacao") {

        // Lógica para processar um pedido em preparação

    } else if (estado === "entrega") {

        // Lógica para processar um pedido em entrega

    } else if (estado === "concluido") {

        // Lógica para processar um pedido concluído

    } else if (estado === "cancelado") {

        // Lógica para processar um pedido cancelado

    } // ... e muitos mais casos

else{return false}

}

Nesse cenário, você tem muitas declarações if-else aninhadas, o que pode ser difícil de ler, manter e depurar. Uma abordagem mais clara e estruturada para resolver esse tipo de situação seria usar uma instrução switch.

A instrução switch avalia uma expressão e executa o bloco de código correspondente ao valor da expressão.

Vejamos como o exemplo acima poderia ser reescrito usando switch:

function processarPedido(estado) {

    switch (estado) {
        case "novo":
            // Lógica para processar um pedido novo
            break;

        case "preparacao":
            // Lógica para processar um pedido em preparação
            break;

        case "entrega":
            // Lógica para processar um pedido em entrega
            break;

        case "concluido":
            // Lógica para processar um pedido concluído
            break;

        case "cancelado":
            // Lógica para processar um pedido cancelado
            break;

        // ... outros casos

        default:
            return false;
    }

}

Vantagens do Switch em JavaScript

A performance do switch em comparação com if pode variar dependendo do contexto e do ambiente em que o código está sendo executado. No entanto, em geral, o switch é frequentemente mais eficiente do que uma série de declarações if-else quando se trata de verificar múltiplas opções em um único valor.

A principal razão para isso é que o switch utiliza uma abordagem de "jump table" (tabela de saltos), que mapeia os valores possíveis diretamente para os blocos de código correspondentes, em vez de avaliar cada condição individualmente como em um conjunto de declarações if-else. Isso resulta em um tempo de execução mais rápido para cenários onde há um grande número de opções a serem verificadas.

Limitações e Considerações

  • Números limitados de casos: quando há apenas um número limitado de casos para verificar, a diferença de desempenho entre switch e if-else pode ser insignificante, especialmente para valores pequenos;
  • JavaScript JIT compilation: Os motores JavaScript modernos, como o V8 (utilizado no Chrome e no Node.js), realizam otimizações em tempo de execução, incluindo a otimização de construções if-else e switch. Portanto, a diferença de desempenho pode ser menos notável em muitos casos;
  • Complexidade do código: A legibilidade e a manutenção do código também são fatores importantes. O switch pode se tornar menos legível quando há muitos casos ou a lógica dentro dos casos é complexa. Nesses casos, a clareza do código pode ser mais importante do que pequenas diferenças de desempenho;
  • Comparação de Strings: A performance do switch pode ser afetada negativamente ao comparar strings muito longas, pois a comparação de igualdade estrita é usada. Em algumas situações, é mais eficiente usar um objeto ou um mapa para mapear strings para ações.

Exemplo prático sobre comparação de Strings:

// Usando um objeto para mapear nomes de países para ações

const acoesPorPais = {

    "EUA": function() {

        console.log("Você está nos Estados Unidos.");

    },

    "Canadá": function() {

        console.log("Você está no Canadá.");

    },

    "Brasil": function() {

        console.log("Você está no Brasil.");

    },

};

// Nome do país que você deseja verificar

const nomePais = "Brasil";

// Verifica se o país existe no objeto e executa a ação correspondente

if (acoesPorPais[nomePais]) {

    acoesPorPais[nomePais]();

} else {

    console.log("País não reconhecido.");

}

Criamos um objeto que mapeia nomes de países para funções que executam ações específicas. Em seguida, podemos verificar se o país existe no objeto e executar a função correspondente. Isso evita a necessidade de escrever um switch longo com várias cláusulas case.

Fall-through

O "fall-through" é um comportamento interessante na estrutura switch onde o código de um caso é executado e, em seguida, a execução continua nos casos subsequentes, a menos que haja um break para interrompê-la. Isso pode ser usado para agrupar casos com ações semelhantes ou para criar lógicas mais complexas.

  • Agrupamento de Casos Similares: o "fall-through" é útil quando você tem vários casos consecutivos que devem executar a mesma lógica. Em vez de repetir o código em cada caso, você pode agrupá-los e ter o código compartilhado. Isso torna seu código mais limpo e fácil de manter;
  • Lógica Complexa: em alguns casos, você pode querer criar lógicas mais complexas onde múltiplos casos precisam ser avaliados antes que a execução seja interrompida. O "fall-through" permite criar essas lógicas de maneira mais eficiente.

Evitando “fall-Through” não Intencional

  • Use Breaks Adequadamente: a maneira mais direta de evitar o "fall-through" não intencional é usar instruções “break” adequadamente. Certifique-se de incluir “break” no final de cada caso onde a execução deve ser interrompida após o código desse caso;
  • Comentários Descritivos: às vezes, é útil adicionar comentários descritivos nos casos onde você usa o “fall-through” de forma intencional. Isso ajuda a documentar a sua intenção e evita confusões;
  • Default no Final: coloque a cláusula “default” (caso padrão) no final do switch. Isso ajuda a evitar o “fall-through” não intencional, pois qualquer execução não controlada será capturada pelo “default“.

O "fall-through" pode ser uma ferramenta poderosa, mas também pode levar a erros sutis com o uso descuidado. Portanto, é importante estar ciente desse comportamento e adotar práticas que evitem problemas não intencionais de "fall-through".

Um exemplo para ilustrar o conceito de "fall-through" em JavaScript:

const diaDaSemana = "segunda";

switch (diaDaSemana) {

    case "segunda":

        console.log("Hoje é segunda-feira.");

        // Nenhum break aqui, permitindo o "fall-through"

    case "terça":

        console.log("A semana está apenas começando.");

        break;

    case "quarta":

    case "quinta":

        console.log("Estamos no meio da semana.");

        break;

    case "sexta":

        console.log("É sexta-feira! Hora de relaxar.");

        break;

    default:

        console.log("Fim de semana à vista!");

        break;

}

No exemplo, “segunda” é o valor de diaDaSemana. Executa-se o caso e, sem o break, continua no caso “terça“. O break em “terça” interrompe a execução.

A seguir está um exemplo de uma cláusula case sequencial de operação múltipla, onde, dependendo do número inteiro fornecido, você pode receber saídas diferentes. Isso mostra que ele percorrerá a ordem em que você colocou as cláusulas case e não precisa ser numericamente sequencial.

Em JavaScript, você também pode misturar definições de strings nessas instruções case.

Exemplo prático

const foo = 1;

let output = "Saída: ";

switch (foo) {

  case 0:

    output += "Então ";

  case 1:

    output += "O que ";

    output += "é ";

  case 2:

    output += "o ";

  case 3:

    output += "seu ";

  case 4:

    output += "Nome";

  case 5:

    output += "?";

    console.log(output);

    break;

  case 6:

    output += "!";

    console.log(output);

    break;

  default:

    console.log("Por favor, escolha um número de 0 a 5!");

}
ValueTexto
foo is NaN or not 1, 2, 3, 4, 5, or 0Por favor, escolha um número de 0 a 5!
0Output: Então O que é o seu Nome?
1Output: O que é o seu Nome?
2Output: seu Nome?
3Output: Nome?
4Output: ?
5Output: !

Note que o "fall-through" pode ser intencional ou não intencional, e é importante estar ciente desse comportamento ao escrever código com a estrutura switch. Caso não se deseje o "fall-through", é importante incluir o break no caso apropriado.

Lembrando também que muitos desenvolvedores preferem evitar o "fall-through" para manter um comportamento mais previsível e legível no código.

Dicas para um Uso Eficiente

Vamos imaginar que você está construindo um sistema de pedidos em um restaurante online e deseja implementar um menu interativo em JavaScript. Esse menu sendo similar aos menus vistos frequentemente em programas em C. Vamos criar um exemplo simples onde o usuário pode selecionar diferentes opções e o programa responderá de acordo usando a estrutura switch.

// Exemplo de menu interativo em JavaScript usando switch

console.log("Bem-vindo ao Restaurante Saboroso!");

console.log("1. Fazer um pedido");

console.log("2. Verificar status do pedido");

console.log("3. Sair");

// Simulando a entrada do usuário (valor da opção escolhida)

const opcao = 2;

// Utilizando a estrutura switch para responder à escolha do usuário

switch (opcao) {

    case 1:

        console.log("Você escolheu fazer um pedido. Por favor, escolha os itens.");

        // Lógica para fazer o pedido

        break;

    case 2:

        console.log("Você escolheu verificar o status do pedido.");

        // Lógica para verificar o status do pedido

        break;

    case 3:

        console.log("Você escolheu sair. Obrigado por visitar o Restaurante Saboroso!");

        // Lógica para sair

        break;

    default:

        console.log("Opção inválida. Por favor, escolha uma opção válida.");

        // Lógica para opção inválida

        break;

}

Menus assim são uma prática comum para ensino superior, e pode-se facilmente implementar variações dela para qualquer linguagem de programação.

Conclusão

Em resumo, o Switch em Javascript é uma poderosa ferramenta para lidar com múltiplas alternativas de um valor, oferecendo uma abordagem estruturada e eficiente. Sua sintaxe organizada e enxuta torna as decisões complexas mais compreensíveis e menos propensas a erros humanos.

É importante lembrar que, embora o switch ofereça vantagens de desempenho em comparação com uma série de declarações if-else em muitos casos, a clareza e a manutenção do código também são fundamentais. Escolha a estrutura que melhor atenda às necessidades específicas do seu projeto.

Em última análise, o switch é um ator versátil no palco da programação JavaScript, assim, capaz de simplificar a tomada de decisões complexas e melhorar a legibilidade do código. Dominar essa construção, portanto, é uma habilidade valiosa para qualquer desenvolvedor JavaScript.

Este artigo foi útil?

Obrigado pela resposta!
Daiana S

Daiana S

Graduada em Letras pelo Instituto Federal da Paraíba e especializada em redação geral. Gosto de escrever sobre tudo e me dedico em vários níveis de expressividade. No geral, todos os meus hobbies giram em torno de escrever alguma coisa e fazer isso bem.

Contato: daiana.blog@homehost.com.br

Ganhe 30% OFF

Indique seu nome e e-mail,e ganhe um cupom de desconto de 30% para sempre na Homehost!