Votre code PHP est rempli de `if…elseif…else` et devient difficile à lire ? C’est un problème courant.
Ce guide vous explique comment utiliser l’instruction `switch` pour simplifier vos conditions avec des exemples clairs.
Syntaxe et exemple fondamental de l’instruction `switch`
Avant de se perdre dans les détails, regardons à quoi ressemble un `switch` en PHP. La syntaxe est simple et directe. Elle permet de vérifier la valeur d’une variable ou d’une expression par rapport à une liste de cas possibles.
Voici la structure de base :
switch (expression) {
case valeur1:
// bloc de code à exécuter si expression = valeur1
break;
case valeur2:
// bloc de code à exécuter si expression = valeur2
break;
default:
// bloc de code à exécuter si aucune correspondance n'est trouvée
}Maintenant, voyons un exemple concret. Imaginons qu’on veuille afficher un message différent selon la couleur préférée de l’utilisateur.
<?php
$favcolor = "red";
switch ($favcolor) {
case "red":
echo "Votre couleur préférée est le rouge !";
break;
case "blue":
echo "Votre couleur préférée est le bleu !";
break;
case "green":
echo "Votre couleur préférée est le vert !";
break;
default:
echo "Votre couleur préférée n'est ni rouge, ni bleu, ni vert !";
}
?>Dans cet exemple, PHP regarde la valeur de la variable `$favcolor`. Il la compare ensuite à chaque `case`. Comme la valeur est « red », le code du `case « red »` est exécuté. L’instruction `break` qui suit est cruciale : elle arrête l’exécution du `switch` et le programme continue après le bloc.
Les composants clés du `switch` : `case`, `break`, et `default`
Pour bien utiliser le `switch case` en PHP, il faut comprendre le rôle de ses trois mots-clés principaux. Chacun a une fonction précise qui détermine comment le code s’exécute.
L’importance cruciale de l’instruction `break`
L’instruction `break` est probablement la partie la plus importante à retenir. Sa fonction est simple : elle met fin à l’exécution du bloc `switch`. Une fois qu’un `case` correspond et que son code est exécuté, le `break` empêche PHP de continuer à lire les autres `case` en dessous.
Mais que se passe-t-il si on oublie le `break` ? PHP va simplement continuer d’exécuter le code des `case` suivants, même si la valeur ne correspond pas. C’est ce qu’on appelle le « fall-through » (ou « chute »). Ça peut être utile dans certains cas, mais c’est le plus souvent une source de bugs.
Regardons un exemple où on oublie volontairement un `break` :
<?php
$i = 0;
switch ($i) {
case 0:
echo "i égal 0. "; // Ce texte sera affiché
case 1:
echo "i égal 1. "; // Ce texte sera AUSSI affiché car il n'y a pas de break au-dessus
break; // Ce break arrête l'exécution ici
case 2:
echo "i égal 2."; // Ce texte ne sera pas affiché
break;
}
// Sortie : i égal 0. i égal 1.
?>Dans le code ci-dessus, comme il n’y a pas de `break` après `case 0`, PHP exécute son code, puis continue directement au `case 1` et exécute aussi son code. Le `break` du `case 1` stoppe enfin le processus. C’est pourquoi il faut toujours mettre un `break` à la fin de chaque `case` sauf si vous voulez ce comportement de « chute » de manière intentionnelle.
Gérer les imprévus avec `default`
Le mot-clé `default` est votre filet de sécurité. Il joue le même rôle que le `else` dans une structure `if`. Le bloc de code sous `default` s’exécute si aucune des valeurs des `case` ne correspond à l’expression fournie au `switch`.
C’est très utile pour gérer les cas inattendus ou pour fournir une réponse par défaut.
- Le `default` est optionnel. Si vous ne le mettez pas et qu’aucun cas ne correspond, rien ne se passe.
- Il ne peut y avoir qu’un seul `default` par `switch`. En mettre plusieurs provoquera une erreur.
- Si `default` est la dernière instruction, le `break` n’est pas nécessaire.
Voici un exemple où la variable `$note` ne correspond à aucun `case` :
<?php
$note = "C";
switch ($note) {
case "A":
echo "Excellent !";
break;
case "B":
echo "Très bien.";
break;
default:
echo "Note invalide ou à améliorer."; // Ce code sera exécuté
}
?>Ici, la variable `$note` contient « C », une valeur qui n’est pas prévue dans les `case`. Le code du bloc `default` est donc exécuté.
Regrouper plusieurs `case`
Parfois, vous voulez exécuter le même bloc de code pour plusieurs valeurs différentes. Au lieu de copier-coller le même code, vous pouvez regrouper les `case`. Pour cela, il suffit de laisser les `case` vides. PHP exécutera alors le code du premier `case` non vide qu’il trouvera en dessous.
C’est une manière très propre de gérer des conditions multiples qui ont le même résultat. Par exemple, pour distinguer les jours de la semaine du week-end :
<?php
$jour = "samedi";
switch ($jour) {
case "lundi":
case "mardi":
case "mercredi":
case "jeudi":
case "vendredi":
echo "C'est un jour de semaine.";
break;
case "samedi":
case "dimanche":
echo "Bon week-end !"; // Ce code sera exécuté
break;
default:
echo "Jour inconnu.";
}
?>Comme `$jour` est « samedi », PHP trouve le `case « samedi »:`. Ce `case` est vide, donc il « tombe » sur le suivant, `case « dimanche »:`. Ce dernier a un bloc de code, qui est donc exécuté. Le `break` stoppe ensuite le `switch`.
`switch` vs. `if…elseif…else` : lequel choisir ?
L’instruction `switch` est souvent présentée comme une alternative à une longue série de `if…elseif…else`. Les deux structures permettent de gérer des conditions, mais elles ne sont pas toujours interchangeables. Le choix dépend de la clarté et de la performance.
Un `switch` est généralement plus lisible quand vous comparez une seule variable à plusieurs valeurs fixes. L’intention du code est plus claire d’un seul coup d’œil.
Voici une comparaison directe du même code :
Code avec `if…elseif…else`
if ($favcolor == "red") {
echo "Votre couleur préférée est le rouge !";
} elseif ($favcolor == "blue") {
echo "Votre couleur préférée est le bleu !";
} elseif ($favcolor == "green") {
echo "Votre couleur préférée est le vert !";
} else {
echo "Votre couleur préférée n'est ni rouge, ni bleu, ni vert !";
}Et son équivalent avec `switch` :
switch ($favcolor) {
case "red":
echo "Votre couleur préférée est le rouge !";
break;
case "blue":
echo "Votre couleur préférée est le bleu !";
break;
case "green":
echo "Votre couleur préférée est le vert !";
break;
default:
echo "Votre couleur préférée n'est ni rouge, ni bleu, ni vert !";
}La différence majeure se situe au niveau de la performance. Dans un `switch`, l’expression (`$favcolor`) est évaluée une seule fois au début. Dans la structure `if…elseif`, chaque condition est évaluée l’une après l’autre jusqu’à ce qu’une soit vraie. Sur un grand nombre d’itérations, `switch` peut être plus rapide.
Info performance : Un benchmark sur un milliard d’itérations a montré que `switch` est plus performant qu’une structure `if/elseif` (42 secondes contre 69 secondes).
Cependant, le `switch` a une limite : il ne fait que des comparaisons d’égalité (avec l’opérateur `==`). Si vous avez besoin de faire des conditions plus complexes (comme `>` ou `<`), vous devrez obligatoirement utiliser un `if`.
Techniques avancées et cas d’usage spécifiques
Le `switch` peut faire plus que de simples comparaisons de chaînes de caractères ou de nombres. Il existe des manières plus avancées de l’utiliser pour résoudre des problèmes complexes.
Utiliser des expressions dans les `case`
La valeur d’un `case` n’est pas limitée à une valeur statique comme « red » ou 5. Vous pouvez aussi y mettre une expression qui sera évaluée par PHP. Le résultat de cette expression sera alors comparé à la valeur du `switch`.
Cela permet de créer des conditions dynamiques.
<?php
$target = 2;
$start = 5;
switch ($target) {
case $start - 1: // ceci est évalué à 4
echo "A";
break;
case $start - 3: // ceci est évalué à 2
echo "B"; // Ce cas correspondra
break;
case $start - 5: // ceci est évalué à 0
echo "C";
break;
}
// Sortie : B
?>Dans cet exemple, `$target` vaut 2. PHP évalue chaque `case` : `$start – 1` donne 4, ce qui ne correspond pas. `$start – 3` donne 2, ce qui correspond. Le code associé est donc exécuté.
Le pattern `switch(true)` pour des conditions complexes
On a dit plus tôt que `switch` ne gérait pas les comparaisons comme `>` ou `<`. C'est vrai, mais il y a une astuce pour contourner ça : le pattern `switch(true)`. Il permet de simuler le comportement d'un `if...elseif...else` avec des conditions complexes.
L’idée est de mettre `true` comme expression à évaluer dans le `switch`. Ensuite, chaque `case` contient une condition complète qui retournera `true` ou `false`. Le `switch` exécutera alors le premier `case` dont la condition retourne `true`.
C’est une manière élégante de gérer des fourchettes de valeurs, par exemple :
<?php
$age = 25;
switch (true) {
case ($age < 18):
echo "Mineur";
break;
case ($age >= 18 && $age <= 65):
echo "Adulte"; // Cette condition est vraie
break;
default:
echo "Senior";
}
// Sortie : Adulte
?>Ici, `switch(true)` cherche le premier `case` qui est vrai. La première condition `($age < 18)` est fausse. La deuxième `($age >= 18 && $age <= 65)` est vraie, donc son code est exécuté et le `break` arrête tout.
Points d'attention et syntaxe alternative
Pour finir, voici quelques points importants à garder en tête et une syntaxe alternative moins connue.
- Syntaxe alternative : PHP propose une autre syntaxe pour le `switch`, qui peut être plus lisible dans les templates HTML : `switch(): ... endswitch;`. Les accolades sont remplacées par deux-points (`:`) et le mot-clé `endswitch;`.
<?php switch ($i):
case 0:
echo "i égal 0";
break;
case 1:
echo "i égal 1";
break;
endswitch; ?>- Comparaison large (`==`) : Faites attention, le `switch` utilise une comparaison large (non stricte). `switch(0)` correspondra à `case "a"` car `"a" == 0` est vrai en PHP. Ce comportement a été modifié pour les comparaisons entre chaînes et nombres depuis PHP 8, mais la prudence reste de mise.
- `continue` dans un `switch` : Dans une boucle, si vous mettez un `switch` à l'intérieur, l'instruction `continue` dans le `switch` se comportera comme un `break`. Pour affecter la boucle externe, il faut utiliser `continue 2`.
Ce qu'il faut retenir
L'instruction `switch` en PHP est un outil simple et efficace pour gérer des conditions multiples sur une seule variable. Elle rend le code plus lisible qu'une longue suite de `if` et peut offrir de meilleures performances.
En maîtrisant `case`, `break`, et `default`, vous pouvez écrire un code plus propre, plus rapide et plus facile à maintenir.
