Switch statement PHP : 5 cas d’usage avec exemples

En douze ans de développement PHP, j’ai écrit des centaines de structures conditionnelles. Et je peux vous dire que le switch statement en PHP reste l’un des outils les plus sous-estimés du langage. Trop de développeurs se contentent de chaînes de if-elseif interminables alors qu’un switch rendrait leur code bien plus lisible et maintenable. Dans ce guide, je vous montre exactement comment et quand l’utiliser, avec cinq cas d’usage tirés de projets réels.

Qu’est-ce qu’un switch statement en PHP ?

Un switch statement est une structure de contrôle conditionnelle qui évalue une expression unique et la compare à une série de valeurs définies dans des blocs case. Contrairement à une série de if-elseif, le switch se concentre sur une seule variable testée contre plusieurs valeurs possibles.

Concrètement, PHP prend la valeur que vous lui passez, la compare séquentiellement à chaque case, et exécute le bloc de code correspondant à la première correspondance trouvée. Si aucun case ne correspond, le bloc default prend le relais.

Un point essentiel que beaucoup de débutants ignorent : le switch utilise une comparaison lâche (==), pas une comparaison stricte (===). Cela signifie que 0 sera considéré égal à "0" ou même à false. J’y reviens en détail plus bas, car c’est la source de bugs les plus courants avec cette structure. Pour approfondir les bases de cette structure, consultez mon guide complet sur PHP switch.

Syntaxe complète et fonctionnement interne

Voici la syntaxe de base du switch statement en PHP :

<?php
switch ($variable) {
    case 'valeur1':
        // Code exécuté si $variable == 'valeur1'
        break;
    case 'valeur2':
        // Code exécuté si $variable == 'valeur2'
        break;
    case 'valeur3':
        // Code exécuté si $variable == 'valeur3'
        break;
    default:
        // Code exécuté si aucun case ne correspond
        break;
}

Trois éléments sont indispensables à comprendre :

• Le mot-clé break : il stoppe l’exécution du switch après le bloc correspondant. Sans lui, PHP continue d’exécuter les blocs suivants, c’est le comportement dit « fall-through ».
• Le bloc default : il agit comme filet de sécurité. Je le place systématiquement dans tous mes switch, même quand je pense avoir couvert tous les cas.
• La comparaison lâche : le switch utilise == et non ===. C’est un choix historique du langage, documenté dans la documentation officielle PHP sur le switch.

Le fall-through peut aussi être un avantage volontaire quand vous souhaitez grouper plusieurs valeurs :

<?php
switch ($extension) {
    case 'jpg':
    case 'jpeg':
    case 'png':
    case 'webp':
        echo 'Fichier image accepté';
        break;
    case 'pdf':
        echo 'Document PDF';
        break;
    default:
        echo 'Format non supporté';
}

Cette technique est très courante pour regrouper plusieurs case dans un même bloc, et je l’utilise quotidiennement dans mes projets WordPress.

5 cas d’usage concrets avec exemples de code

Cas n°1 : routage d’une application

Le premier usage classique du switch, c’est le routage simplifié. Avant d’utiliser un framework, beaucoup de projets PHP gèrent leurs pages avec un switch sur un paramètre d’URL :

<?php
$page = $_GET['page'] ?? 'accueil';

switch ($page) {
    case 'accueil':
        include 'templates/home.php';
        break;
    case 'contact':
        include 'templates/contact.php';
        break;
    case 'blog':
        include 'templates/blog.php';
        break;
    case 'mentions-legales':
        include 'templates/legal.php';
        break;
    default:
        http_response_code(404);
        include 'templates/404.php';
        break;
}

Ce pattern est idéal pour les petits sites PHP natifs. J’ai souvent recours à cette approche pour des landing pages ou des microsites où un framework complet serait surdimensionné. Pour aller plus loin sur le choix entre PHP natif et framework, j’ai rédigé un comparatif détaillé.

Cas n°2 : gestion des rôles utilisateur

La gestion des permissions selon les rôles est un cas d’usage parfait pour le switch. Le code est bien plus lisible qu’une cascade de if :

<?php
function getPermissions(string $role): array
{
    switch ($role) {
        case 'admin':
            return ['read', 'write', 'delete', 'manage_users'];
        case 'editor':
            return ['read', 'write', 'delete'];
        case 'author':
            return ['read', 'write'];
        case 'subscriber':
            return ['read'];
        default:
            return [];
    }
}

$permissions = getPermissions('editor');
// Résultat : ['read', 'write', 'delete']

Notez ici que j’utilise return au lieu de break. Le return quitte la fonction entière, ce qui rend le break inutile. C’est une bonne pratique que je recommande systématiquement quand le switch se trouve dans une fonction.

Cas n°3 : machine à états (workflow)

Dans les projets e-commerce ou les systèmes de gestion de commandes, le switch excelle pour gérer les transitions d’états :

<?php
function handleOrderStatus(string $status, int $orderId): string
{
    switch ($status) {
        case 'pending':
            sendConfirmationEmail($orderId);
            return 'Commande en attente de paiement';
        case 'paid':
            notifyWarehouse($orderId);
            return 'Paiement reçu, préparation en cours';
        case 'shipped':
            $tracking = generateTrackingNumber($orderId);
            sendTrackingEmail($orderId, $tracking);
            return 'Commande expédiée';
        case 'delivered':
            requestFeedback($orderId);
            return 'Commande livrée';
        case 'refunded':
            processRefund($orderId);
            return 'Remboursement effectué';
        default:
            logError("Statut inconnu : $status pour commande $orderId");
            return 'Statut non reconnu';
    }
}

Ce pattern est directement applicable dans WooCommerce ou tout système de commande maison. Chaque état déclenche des actions spécifiques, et le default journalise les anomalies.

Cas n°4 : traitement de données de formulaire

Le switch est très efficace pour valider et traiter les données issues de formulaires HTML, notamment les champs <select> :

<?php
$action = $_POST['action'] ?? '';

switch ($action) {
    case 'inscription':
        $result = registerUser($_POST);
        break;
    case 'connexion':
        $result = loginUser($_POST['email'], $_POST['password']);
        break;
    case 'reset_password':
        $result = sendPasswordReset($_POST['email']);
        break;
    case 'update_profile':
        $result = updateProfile($_SESSION['user_id'], $_POST);
        break;
    default:
        $result = ['error' => 'Action non reconnue'];
        break;
}

echo json_encode($result);

Ce type de dispatch est courant dans les endpoints AJAX. Plutôt que de créer un fichier par action, un seul script PHP avec un switch centralise le traitement. Pour manipuler les données reçues, j’utilise souvent la fonction explode en complément.

Cas n°5 : routeur d’API REST

Pour une API REST légère, le switch sur la méthode HTTP est un classique que j’implémente régulièrement :

<?php
$method = $_SERVER['REQUEST_METHOD'];
$resource = $_GET['resource'] ?? '';

switch ($method) {
    case 'GET':
        $response = fetchResource($resource);
        http_response_code(200);
        break;
    case 'POST':
        $data = json_decode(file_get_contents('php://input'), true);
        $response = createResource($resource, $data);
        http_response_code(201);
        break;
    case 'PUT':
        $data = json_decode(file_get_contents('php://input'), true);
        $response = updateResource($resource, $data);
        http_response_code(200);
        break;
    case 'DELETE':
        $response = deleteResource($resource);
        http_response_code(204);
        break;
    default:
        $response = ['error' => 'Méthode non autorisée'];
        http_response_code(405);
        break;
}

header('Content-Type: application/json');
echo json_encode($response);

Ce pattern est la base de nombreuses API maison. Pour les téléchargements de fichiers via cette API, vous pouvez combiner cette approche avec les méthodes de téléchargement en PHP.

Switch vs if-elseif : quand choisir l’un ou l’autre

C’est la question que me posent le plus souvent les développeurs juniors. Voici ma règle personnelle, forgée par l’expérience : si vous comparez une seule variable à plus de trois valeurs distinctes, prenez le switch. En dessous, le if-elseif reste plus concis.

En résumé : le switch est plus lisible et structuré pour les comparaisons d’égalité multiples. Le if-elseif est plus flexible pour les conditions complexes, les intervalles de valeurs ou les comparaisons strictes. Pour aller plus loin sur les structures imbriquées, consultez mon article sur le switch imbriqué en PHP.

Switch vs match : les nouveautés de PHP 8

Depuis PHP 8.0, l’expression match est venue compléter le switch. Et après deux ans d’utilisation intensive, je peux dire que match résout les deux plus gros problèmes du switch : le fall-through accidentel et la comparaison lâche.

<?php
// Avec switch (PHP 7+)
switch ($statusCode) {
    case 200:
        $message = 'OK';
        break;
    case 301:
        $message = 'Redirection permanente';
        break;
    case 404:
        $message = 'Page non trouvée';
        break;
    case 500:
        $message = 'Erreur serveur';
        break;
    default:
        $message = 'Code inconnu';
        break;
}

// Avec match (PHP 8+)
$message = match ($statusCode) {
    200 => 'OK',
    301 => 'Redirection permanente',
    404 => 'Page non trouvée',
    500 => 'Erreur serveur',
    default => 'Code inconnu',
};

Les différences clés entre switch et match :

• match utilise === (comparaison stricte) : plus de surprises avec les conversions de type
• match est une expression : elle retourne une valeur, ce qui permet l’affectation directe
• Pas de fall-through : chaque branche est isolée, pas besoin de break
• match lève une erreur si aucune branche ne correspond et qu’il n’y a pas de default (UnhandledMatchError)

Mon conseil : si votre projet tourne sur PHP 8 ou supérieur, privilégiez match pour les affectations simples. Gardez le switch quand vous avez besoin d’exécuter plusieurs instructions par branche ou quand le fall-through est intentionnel. Pour approfondir cette comparaison, j’en parle en détail dans mon article dédié au case switch PHP.

Erreurs fréquentes et bonnes pratiques

En revue de code, je tombe régulièrement sur les mêmes erreurs avec le switch. Voici les cinq pièges les plus courants et comment les éviter.

1. Oublier le break

C’est l’erreur numéro un. Sans break, le code « tombe » dans le case suivant :

<?php
$fruit = 'pomme';

switch ($fruit) {
    case 'pomme':
        echo 'Fruit rouge';
        // Oubli du break !
    case 'banane':
        echo 'Fruit jaune';
        break;
}
// Affiche : "Fruit rougeFruit jaune" — ce n'est pas ce qu'on veut

2. Ignorer la comparaison lâche

Le switch compare avec ==. Cela peut provoquer des comportements inattendus :

<?php
$valeur = 0;

switch ($valeur) {
    case 'texte':
        echo 'Surprise !';
        break;
    case 0:
        echo 'Zéro';
        break;
}
// En PHP 7, affiche "Surprise !" car 0 == 'texte' est true
// En PHP 8, le comportement a été corrigé pour les comparaisons string/int

La question revient souvent : est-il mieux d’utiliser == ou === en PHP ? La réponse est simple : privilégiez toujours === sauf raison explicite. Comme le switch ne supporte que ==, soyez vigilant sur les types, ou passez à match si vous êtes en PHP 8+. La table de comparaison des types PHP est votre meilleure référence sur ce sujet.

3. Ne pas mettre de default

Un switch sans default, c’est comme un filet troué. Prévoyez toujours un cas par défaut, même si c’est juste pour journaliser l’anomalie.

4. Mettre des conditions complexes dans les case

Les case n’acceptent que des valeurs scalaires. Si vous avez besoin de tester des intervalles ou des expressions, utilisez un if-elseif ou la syntaxe suivante (peu recommandée mais fonctionnelle) :

<?php
$age = 25;

switch (true) {
    case ($age < 18):
        echo 'Mineur';
        break;
    case ($age < 65):
        echo 'Adulte';
        break;
    default:
        echo 'Senior';
        break;
}

Cette technique fonctionne mais je la déconseille : elle détourne la logique du switch et un if-elseif serait plus clair ici.

5. Dupliquer du code entre les case

Si plusieurs case exécutent un code identique, utilisez le fall-through plutôt que de copier-coller :

<?php
// Mauvais : code dupliqué
switch ($jour) {
    case 'lundi':
        echo 'Jour ouvré';
        break;
    case 'mardi':
        echo 'Jour ouvré';
        break;
    // ...
}

// Bon : fall-through volontaire
switch ($jour) {
    case 'lundi':
    case 'mardi':
    case 'mercredi':
    case 'jeudi':
    case 'vendredi':
        echo 'Jour ouvré';
        break;
    case 'samedi':
    case 'dimanche':
        echo 'Week-end';
        break;
}

Cas avancés et astuces de développeur

Switch avec des constantes et des énumérations

En PHP 8.1+, les enums fonctionnent parfaitement avec le switch et encore mieux avec match :

<?php
enum Couleur: string
{
    case Rouge = 'rouge';
    case Bleu = 'bleu';
    case Vert = 'vert';
}

function getHexCode(Couleur $couleur): string
{
    return match ($couleur) {
        Couleur::Rouge => '#FF0000',
        Couleur::Bleu => '#0000FF',
        Couleur::Vert => '#00FF00',
    };
}

Switch dans un contexte WordPress

En développement WordPress, le switch est omniprésent dans les hooks et filtres. Voici un exemple concret avec un filtre sur le type de contenu :

<?php
add_filter('the_content', function ($content) {
    $post_type = get_post_type();
    
    switch ($post_type) {
        case 'product':
            $content .= renderProductCTA();
            break;
        case 'portfolio':
            $content .= renderPortfolioGallery();
            break;
        case 'testimonial':
            $content .= renderAuthorBio();
            break;
        default:
            // Posts et pages standard : aucune modification
            break;
    }
    
    return $content;
});

Switch et tableaux : combiner les deux

Parfois, un tableau associatif remplace avantageusement un switch. C’est ce qu’on appelle le pattern lookup table :

<?php
// Au lieu de :
switch ($code_pays) {
    case 'FR': $devise = 'EUR'; break;
    case 'US': $devise = 'USD'; break;
    case 'GB': $devise = 'GBP'; break;
    case 'JP': $devise = 'JPY'; break;
    default: $devise = 'EUR'; break;
}

// Préférez :
$devises = [
    'FR' => 'EUR',
    'US' => 'USD',
    'GB' => 'GBP',
    'JP' => 'JPY',
];
$devise = $devises[$code_pays] ?? 'EUR';

Cette approche est plus concise et performante pour les correspondances simples valeur-vers-valeur. Pour les sujets liés aux conversions de devises en PHP, j’ai aussi un guide sur la conversion PHP euro.

Performances et benchmarks

La question revient souvent : un switch est-il plus rapide qu’un if ? La réponse courte est oui, mais avec des nuances. J’ai réalisé des benchmarks sur PHP 8.2 avec 10 millions d’itérations :

Comme vous le voyez, le tableau associatif est le grand gagnant en termes de performance pure, car l’accès est en O(1) quel que soit le nombre d’entrées. L’expression match arrive en deuxième position, suivie du switch puis du if-elseif.

Cependant, soyons honnêtes : ces différences sont négligeables dans la plupart des applications web. La lisibilité et la maintenabilité du code doivent rester vos critères principaux. Ne choisissez jamais une structure uniquement pour gagner quelques microsecondes, sauf si vous travaillez sur du code exécuté des millions de fois par requête.

Pour ceux qui travaillent aussi en JavaScript, les structures conditionnelles fonctionnent différemment. J’ai d’autres guides sur les spécificités JS comme la propriété length des arrays JavaScript ou la méthode splice.