Simplifiez vos conditions en JavaScript avec l'instruction switch

📌 Structure de base de l'instruction switch

L'instruction switch évalue une expression une seule fois, puis compare le résultat à chaque case dans l'ordre, en utilisant une égalité stricte (===).

switch (expression) {
  case valeur1:
    // Code à exécuter si expression === valeur1
    break;
  case valeur2:
    // Code à exécuter si expression === valeur2
    break;
  default:
    // Code à exécuter si aucun cas ne correspond
}

L'expression peut être une variable simple, une propriété d'objet ou le retour d'une fonction :

switch (jour) { ... }                 // Variable simple
switch (utilisateur.statut) { ... }   // Propriété d'objet
switch (calculerNote()) { ... }       // Résultat de fonction

⚠️ Le piège numéro un : le fall-through involontaire

Oublier un break, c'est l'erreur la plus courante avec switch. Sans lui, JavaScript ne s'arrête pas au premier case correspondant : il continue d'exécuter tous les blocs suivants jusqu'au prochain break ou la fin du switch. Ce comportement s'appelle le fall-through.

// Bug classique : break oublié au case 'admin'
let role = 'admin';
switch (role) {
    case 'admin':
        console.log('Accès total');
        // ❌ Pas de break : le code "tombe" dans le case suivant
    case 'editeur':
        console.log('Peut publier des articles');
        break;
    case 'lecteur':
        console.log('Lecture seule');
        break;
}
// Résultat inattendu :
// "Accès total"
// "Peut publier des articles"  ← ne devrait pas s'afficher !

Le fall-through peut néanmoins être utilisé intentionnellement pour regrouper des cas qui partagent le même comportement :

// Fall-through intentionnel : même traitement pour plusieurs valeurs
switch (jour) {
    case 'samedi':
    case 'dimanche':
        console.log('Week-end : bureau fermé');
        break;
    default:
        console.log('Jour ouvré');
}

🎯 La comparaison stricte : attention aux types

switch utilise ===, pas ==. Cela signifie que la valeur et le type doivent correspondre. C'est un piège fréquent lorsque les données viennent d'un formulaire HTML (tout est string) ou d'une API (les types peuvent surprendre).

let note = "3"; // Vient d'un input HTML : c'est une string

switch (note) {
    case 3:
        console.log('Mention passable'); // ❌ Ne s'exécute jamais : 3 !== "3"
        break;
    case "3":
        console.log('Mention passable'); // ✅ Correspond
        break;
}

🎮 Exemple concret : gestion d'actions dans un jeu

Un switch est particulièrement lisible pour mapper des commandes à des comportements distincts :

function combattreMonstre(typeMonstre) {
    switch (typeMonstre) {
        case 'dragon':
            console.log("Vous utilisez votre bouclier anti-feu !");
            break;
        case 'troll':
            console.log("Vous dégainez votre épée en argent !");
            break;
        case 'vampire':
            console.log("Vous sortez votre pieu en bois !");
            break;
        case 'loup-garou':
            console.log("Vous chargez votre pistolet avec des balles en argent !");
            break;
        default:
            console.log("Monstre inconnu. Vous préférez fuir, et c'est souvent la bonne décision.");
    }
}

combattreMonstre('dragon');  // "Vous utilisez votre bouclier anti-feu !"
combattreMonstre('licorne'); // "Monstre inconnu. Vous préférez fuir…"

💡 switch vs objet littéral : quand préférer l'alternative ?

Pour des mappings simples valeur → résultat, un objet littéral est souvent plus court, plus lisible, et plus facile à tester unitairement. C'est une alternative que beaucoup de développeurs ne connaissent pas ou oublie.

// Avec switch
function getLibelleJour(jour) {
    switch (jour) {
        case 1: return 'Lundi';
        case 2: return 'Mardi';
        case 3: return 'Mercredi';
        default: return 'Jour inconnu';
    }
}

// Avec un objet littéral : plus court, facilement extensible
const JOURS = {
    1: 'Lundi',
    2: 'Mardi',
    3: 'Mercredi',
};
const getLibelleJour = (jour) => JOURS[jour] ?? 'Jour inconnu';

En revanche, switch reste préférable quand chaque cas exécute de la logique (plusieurs lignes de code, appels de fonctions, effets de bord) plutôt que de simplement retourner une valeur.

📊 Quand utiliser switch, et quand ne pas le faire

📝 Quelques règles à retenir