Les Conditions
Présentation
Les conditions permettent de créer des bifurcations dans le flux d'exécution du code. En d'autres termes, elles indiquent au programme : « Si quelque chose est vrai, fais ceci ; sinon, fais autre chose. » On construit les conditions de façon progressive avec trois éléments principaux :
- if (si) : Permet d'exécuter un bloc de code uniquement si une condition est vraie.
- elseif (sinon si) : S'ajoute après un if pour tester une nouvelle condition si la première n'était pas remplie. On peut en enchaîner plusieurs.
- else (sinon) : Se place à la fin d'un bloc if ou elseif pour exécuter un bloc de code si aucune des conditions précédentes n'est vraie.
Instructions if, else et elseif
Pour réaliser une condition :
- Vous écrivez if suivi de votre condition entre parenthèses ( la condition ).
- Ensuite vous ouvrez le bloc avec les instructions à exécuter si la condition est vraie, ce bloc est délimité par les accolades { bloc avec les instruction à exécuter } :
if ( la condition )
{
bloc avec les instructions à exécuter...
...
...
}
Pour illustrer le fonctionnement de cette structure, prenons un exemple simple. Supposons que nous voulions vérifier si une personne est majeure. Imaginez que nous ayons une personne nommée Claudy, dont l'âge est de 52 ans :
<?php
// Nous attribuons l'âge de Claudy à une variable :
$claudyAge = 52;
// Si la valeur de la variable $claudyAge est supérieure ou égale à 18 alors exécuter les instructions situées dans le bloc entre accolades :
if ($claudyAge >= 18)
{
echo "La personne est majeure !" . PHP_EOL;
}
// L'instruction suivante étant affichée en dehors de la structure conditionnelle, elle sera exécutée quel que soit le résultat de la condition :
echo 'La condition a été testée !';
/*
Affiche :
La personne est majeur !
La condition a été testée !
*/
?>
Désormais, nous souhaitons avoir la capacité de saisir des âges différents à la volée sans avoir à modifier le code à chaque fois. Pour accomplir cela, nous pouvons utiliser la fonction readline(). Cette fonction, disponible lors de l'exécution d'un script en ligne de commande, permet de personnaliser le texte affiché à l'écran pour guider l'utilisateur. Une fois que l'utilisateur a saisi sa réponse et appuyé sur la touche "Entrée", la valeur qu'il a saisie peut être stockée dans une variable pour une utilisation ultérieure. Il est important de noter que tant que l'utilisateur n'a pas validé en appuyant sur "Entrée", le programme reste en pause :
<?php
/*
1. La fonction readline() affiche la chaîne de caractères située entre les parenthèses.
2. Le programme se met en pause en attendant une entrée de l'utilisateur.
3. Une fois que l'utilisateur valide sa saisie, celle-ci est stockée dans la variable $age et le programme reprend à partir de la ligne suivante.
*/
$age = readline('Veuillez entrer l\'âge à tester : ');
if ($age >= 18)
{
echo "La personne est majeure !" . PHP_EOL;
}
?>
Nous aimerions aussi afficher un message si la personne est mineur et comme une personne est soit majeure soit mineure, nous pouvons utiliser l'instruction else suivi d'un autre bloc d'instructions délimité lui aussi par des accolades :
<?php
$age = readline('Veuillez entrer l\'âge à tester : ');
if ($age >= 18)
{
echo 'La personne est majeure !';
}
else
{
echo 'La personne est mineure !';
}
?>
Il est également possible de tester plusieurs conditions au sein d'une même structure de contrôle conditionnelle en utilisant l'instruction elseif, suivi d'un autre bloc d'instructions délimité par des accolades. Dans l'exemple suivant, nous demandons à l'utilisateur de fournir un nombre représentant les années de mariage, afin que le programme puisse déterminer et afficher le nom de l'anniversaire de mariage correspondant. Nous nous limiterons aux 2 premières années :
<?php
$anneeDeMariage = readline('Veuillez entrer le nombre d\'années de mariage à célébrer : ');
if ($anneeDeMariage == 0)
{
echo 'Bien que le temps puisse vous sembler long, la première année de mariage n\'est pas encore passée !';
}
elseif ($anneeDeMariage == 1)
{
echo 'Félicitations pour les Noces de Coton !';
}
elseif ($anneeDeMariage == 2)
{
echo 'Félicitations pour les Noces de Cuir !';
}
else
{
echo 'Quel courage ! Vous êtes marié depuis plus de 2 ans !';
}
?>
Les Opérateurs de Comparaison
Dans la section précédente, nous avons travaillé avec les opérateurs de comparaison <, >, <= et >=, qui servent à comparer des valeurs numériques en termes d'ordre (plus petit, plus grand, etc.).
Nous abordons maintenant un autre type de comparaison : l'opérateur d'égalité non stricte ==. Il vérifie si deux valeurs sont égales en comparant uniquement leur contenu, sans tenir compte de leur type. Ainsi, comparer la chaîne "1" avec l'entier 1 à l'aide de == renverra la valeur true.
C'est précisément ce fonctionnement qui permet à l'exemple précédent de produire le résultat attendu. La fonction readline() renvoie toujours les données saisies par l'utilisateur sous forme de chaîne de caractères, même lorsque celui-ci entre une valeur numérique. Grâce à l'opérateur ==, la comparaison porte uniquement sur la valeur, sans tenir compte du type des données comparées (entier et chaîne de caractères).
Pour mieux comprendre ce comportement, prenons un exemple concret lié à ce que nous venons d'expliquer à propos des chaînes renvoyées par readline() :
<?php
$anneeDeMariage = readline('Veuillez entrer le nombre 5 :');
$a = 5;
// La fonction prédéfinie "var_dump()" permet de visualiser
// à la fois la valeur et le type d'une donnée.
var_dump($anneeDeMariage); // Affiche : string(1) "5"
var_dump($a); // Affiche : int(5)
// Test d'égalité des deux valeurs avec l'opérateur non strict.
var_dump($anneeDeMariage == $a); // Affiche : bool(true)
?>
Alors que nous avons correctement entré le nombre 5 lorsque readline() nous l'a suggéré, la valeur qui a été stockée dans la variable $anneeDeMariage est bel et bien une chaîne de caractères (string) comprenant un seul caractère, le caractère "5". Ceci démontre que l'opérateur de comparaison == ne prend pas en compte le type de données.
Pour éviter ce genre de situation ambiguë, il est recommandé de convertir les entrées utilisateur dans le type de données attendu après avoir validé leur contenu. Cela permet de s'assurer que votre programme manipule bien un entier lorsque le champ est censé contenir un nombre :
<?php
$anneeDeMariage = readline('Veuillez entrer le nombre 5 :');
$a = "5";
// Conversion explicite en entier après validation
// à l'aide de l'opérateur de transtypage "(int)".
$anneeDeMariage = (int) $anneeDeMariage;
var_dump($anneeDeMariage); // Affiche : int(5)
var_dump($a); // Affiche : string(1) "5"
// Test d'égalité des deux valeurs avec l'opérateur non strict.
var_dump($anneeDeMariage == $a); // Affiche : bool(true)
?>
Il est important de rester prudent lorsque l'on utilise cet opérateur d'égalité non stricte == car il peut conduire à des résultats inattendus lorsque vous comparez des valeurs de types différents.
Supposons que vous demandiez aux utilisateurs de remplir un formulaire HTML où l'un des champs obligatoires est "nombre d'enfants". Pour illustrer ce cas, nous simulons la saisie en assignant directement la valeur 0, ce qui correspond à un utilisateur déclarant ne pas avoir d'enfants :
<?php
// Stocker l'entrée utilisateur du champ "nombreEnfants" après conversion en entier.
// Pour l'exemple, l'utilisateur n'a pas d'enfants et a donc entré la valeur 0.
$nombreEnfants = 0;
// Vérifier que le champ "nombreEnfants" a bien été rempli.
if ($nombreEnfants == null)
{
echo 'Erreur: ce champ est requis !';
}
else
{
echo 'Merci, ce champ est bien rempli !';
}
// 0 == null retourne true car la nature (le type) des deux valeurs n'est pas prise en compte.
// La condition d'echec est remplie -> Affiche : Erreur: ce champ est requis !
?>
Dans cet exemple, pour vérifier si le champ a été rempli, nous le comparons à null (null pour les champs de formulaire HTML n'ayant pas été rempli). Cependant, lorsque vous utilisez l'opérateur ==, null est converti en une valeur équivalente, qui est 0. Étant donné que cet opérateur ne prend pas en compte la comparaison du type de valeurs, cet opérateur considérera que si vous n'avez pas d'enfant, cela équivaut à n'avoir pas rempli le champ.
Pour éviter ce problème, il existe un opérateur qui compare le type en plus de la valeur, il s'agit de l'opérateur d'égalité stricte === :
<?php
$nombreEnfants = 0;
if ($nombreEnfants === null)
{
echo 'Erreur: ce champ est requis !';
}
else
{
echo 'Merci, ce champ est bien rempli !';
}
// 0 === null retourne false car la nature (le type) des deux valeurs est prise en compte.
// La condition d'echec n'est pas remplie -> Affiche : Merci, ce champ est bien rempli !
?>
Si vous souhaitez vérifier si les valeurs sont différentes plutôt qu'égales, il vous suffit de remplacer le premier signe égal par l'opérateur de négation !, que ce soit pour l'opérateur d'égalité non strict != ou strict !== :
<?php
$nombreEnfants = 0;
if ($nombreEnfants !== null)
{
echo 'Merci, ce champ est bien rempli !';
}
else
{
echo 'Erreur: ce champ est requis !';
}
// Affiche : Merci, ce champ est bien rempli !
?>
Il existe d'autres opérateurs de comparaison mais nous ne les aborderons pas dans le cours. Si vous désirez en apprendre plus sur le sujet, veuillez vous rendre sur le site officiel de PHP à la page suivante : https://www.php.net/manual/fr/language.operators.comparison.php.
Notez qu'il est aussi possible d'imbriquer les structure conditionnelles :
<?php
$nombreEnfants = 0;
// Vérifier que le champ a bien été rempli par l'utilisateur.
if ($nombreEnfants !== null)
{
// Si le champ a bien été rempli, ce message sera toujours affiché en premier,
// quel que soit le nombre d'enfants saisi par l'utilisateur.
echo 'Merci, ce champ est bien rempli ';
// Afficher un message en fonction du nombre d'enfants entré l'utilisateur.
if ($nombreEnfants > 5)
{
echo 'et vous avez beaucoup d\'enfants !';
}
elseif ($nombreEnfants > 0)
{
echo "et vous avez $nombreEnfants enfant(s) !";
}
else
{
echo 'et apparemment, vous n\'avez pas d\'enfants !';
}
}
else
{
echo 'Erreur: ce champ est requis !';
}
// Affiche : Merci, ce champ est bien rempli et apparemment, vous n'avez pas d'enfants !
?>
Conversion implicite en booléens
Jusqu'à présent, nous avons utilisé des opérateurs de comparaison (<, >, ==, etc.) afin que l'expression placée entre parenthèses dans une condition retourne explicitement true ou false. Cependant, il n'est pas toujours nécessaire d'écrire une comparaison. PHP évalue automatiquement toute expression placée dans une condition en booléen. Cela peut être une variable, une valeur littérale, le résultat d'une opération ou encore le retour d'une fonction. Autrement dit, certaines valeurs sont interprétées comme "fausses" (falsy) et d'autres comme "vraies" (truthy).
Reprenons l'exemple qui vérifiait si le champ "nombre d'enfants" avait bien été rempli (en testant si la valeur de $nombreEnfants était différente de null). Plutôt que d'écrire if ($nombreEnfants !== null), on peut simplifier avec if ($nombreEnfants). En effet, si $nombreEnfants vaut null, il sera implicitement converti en bool(false) (c'est-à-dire falsy) :
<?php
$nombreEnfants = null;
// La condition du if n'attend pas forcément un booléen strict.
// PHP convertit automatiquement $nombreEnfants en booléen.
// Comme null est converti en false (valeur "falsy"),
// c'est le bloc else qui s'exécute.
if ($nombreEnfants)
{
echo 'Merci, ce champ est bien rempli ';
}
else
{
echo 'Erreur: ce champ est requis !';
}
// Affiche : Erreur: ce champ est requis !
?>
Pour mieux comprendre ce qui se passe, on peut forcer la conversion de la variable en booléen à l'aide de l'opérateur de transtypage (bool) :
<?php
$nombreEnfants = null;
// Conversion explicite en booléen
$nombreEnfantsBool = (bool) $nombreEnfants;
var_dump($nombreEnfants); // Affiche : NULL
var_dump($nombreEnfantsBool); // Affiche : bool(false)
?>
Les principales valeurs évaluées comme false sont :
- false
- null
- 0 (entier zéro)
- 0.0 (flottant zéro)
- "" (chaîne vide)
- "0" (chaîne contenant uniquement le chiffre zéro — particularité propre à PHP)
- [] (tableau vide)
Toutes les autres valeurs sont considérées comme true.
Il faut toutefois rester prudent lorsque l'on utilise cette écriture simplifiée. Reprenons notre exemple où il faut entrer le nombre d'enfants. Si l'utilisateur entre le nombre 0 (c'est-à-dire qu'il déclare ne pas avoir d'enfants), la condition if ($nombreEnfants) ne s'exécutera pas. En effet, en PHP, la valeur 0 est considérée comme falsy, et donc évaluée à false. On retombe alors sur le même type de problème rencontré avec l'opérateur ==, où certaines valeurs peuvent être interprétées de manière inattendue.
<?php
$nombreEnfants = 0;
// La condition du if n'attend pas forcément un booléen strict.
// PHP convertit automatiquement $nombreEnfants en booléen.
// Comme 0 est converti en false (valeur "falsy"),
// c'est le bloc else qui s'exécute.
if ($nombreEnfants)
{
echo 'Merci, ce champ est bien rempli ';
}
else
{
echo 'Erreur: ce champ est requis !';
}
// Affiche : Erreur: ce champ est requis !
?>
Notez que ce même piège existe avec la fonction prédéfinie empty(). Cette fonction retourne true si la valeur passée est considérée comme "vide" selon les règles des valeurs falsy. Autrement dit, empty(0) ou empty("0") renverront aussi true, ce qui peut être problématique si l'on souhaite faire la distinction entre "aucune valeur saisie" et "zéro". C'est pour cette raison que certains développeurs préfèrent éviter empty() et privilégier des comparaisons explicites plus précises.
Les Opérateurs Logiques
Il est également possible de combiner les opérateurs de comparaison avec des opérateurs logiques. Les deux opérateurs logiques les plus couramment utilisés sont "ET" AND (ou &&), qui vérifie si toutes les conditions sont vraies, et "OU" OR (ou ||), qui vérifie si au moins une des conditions est vraie.
Dans l'exemple suivant, nous avons deux variables servant à définir les caractéristiques d'une balle. Utilisons l'opérateur logique "ET" (&&) pour vérifier si la balle est lisse ET rouge :
<?php
$balleTexture = 'lisse';
$balleCouleur = 'rouge';
// Si toutes les caractéristiques de la balle sont respectées alors la condition est vraie :
if ($balleTexture === 'lisse' && $balleCouleur === 'rouge')
{
echo 'Il s\'agit de la bonne balle !';
}
else
{
echo 'Il ne s\'agit pas de la bonne balle !';
}
// Affiche : Il s'agit de la bonne balle !
?>
Utilisons mainenant l'opérateur logique "OU" (||) pour vérifier si la balle est rouge OU si elle est lisse ou encore si elle est rouge et lisse :
<?php
$balleTexture = 'lisse';
$balleCouleur = 'rouge';
// Si au moins l'une des caractéristiques de la balle est respectée, alors la condition est vraie :
if ($balleTexture === 'rugueux' || $balleCouleur === 'rouge')
{
echo 'Il s\'agit de la bonne balle !';
}
else
{
echo 'Il ne s\'agit pas de la bonne balle !';
}
// Affiche : Il s'agit de la bonne balle !
?>
Notez qu'il existe un autre opérateur, le XOR qui représente un "OU exclusif". Dans ce cas, la combinaison est valide uniquement si une seule des conditions retourne "VRAI".
<?php
$balleTexture = 'lisse';
$balleCouleur = 'rouge';
// Si une seule des caractéristiques de la balle est respectée, alors la condition est vraie :
if ($balleTexture === 'lisse' xor $balleCouleur === 'rouge')
{
echo 'Il s\'agit de la bonne balle !';
}
else
{
echo 'Il ne s\'agit pas de la bonne balle !';
}
// Affiche : Il ne s'agit pas de la bonne balle !
?>
Pour résumer, voici les tables de vérité qui permettent de représenter toutes les combinaisons possibles de valeurs de vérité (vrai ou faux) et ainsi de déterminer le résultat d'une expression logique pour chaque combinaison d'entrées :
De la même manière qu'avec les simples opérateurs de comparaison, il est possible de tester la négation du résultat d'une expression :
<?php
$balleTexture = 'lisse';
$balleCouleur = 'rouge';
/*
- Si au moins une des caractéristiques de la balle N'EST PAS respectée alors la
condition est vraie :
1. ($balleTexture === 'rugueux' && $balleCouleur === 'rouge') = (false && true)
2. (false && true) = false
3. !false = true
*/
if (!($balleTexture === 'rugueux' && $balleCouleur === 'rouge'))
{
echo 'Il ne s\'agit pas de la bonne balle !';
}
else
{
echo 'Il s\'agit de la bonne balle !';
}
// Affiche : Il ne s'agit pas de la bonne balle !
?>
Si vous utilisez plusieurs opérateurs logiques, vous pourriez être confronté à quelques résultats inattendus. En effet, les opérateurs logiques ont une priorité d'évaluation, et cela affecte le résultat de la condition.
Voici les opérateurs par ordre de priorité :
- Les parenthèses : ()
- L'opérateur NON : !
- l'opérateur ET : &&
- L'opérateur OU : ||
Dans l'exemple suivant, on aimerait vérifier que la bonne balle soit lisse ou rugueuse et obligatoirement de couleur verte :
<?php
$balleTexture = 'lisse';
$balleCouleur = 'rouge';
/*
L'opérateur "&&" étant prioritaire sur l'opérateur "||," l'évaluation de la
condition se déroule comme suit :
1. ($balleTexture === 'rugueux' && $balleCouleur === 'vert') = (false && false) = false
2. ($balleTexture === 'lisse' || false) = (true || false) = true
*/
if ($balleTexture === 'lisse' || $balleTexture === 'rugueux' && $balleCouleur === 'vert')
{
echo 'Il s\'agit de la bonne balle !';
}
// Affiche : Il s'agit de la bonne balle !
?>
L'ordre des priorités a eu un impact sur le résultat. L'opérateur logique ET && étant prioritaire, l'évaluation de la condition a débuté avec la combinaison du test sur la couleur ($balleCouleur === 'vert') et sur la texture ($balleTexture === 'rugueux').
N'oubliez pas que l'utilisation de parenthèses pour clarifier l'ordre d'évaluation peut éviter ce genre de confusion :
<?php
$balleTexture = 'lisse';
$balleCouleur = 'rouge';
/*
Les parenthèses étant prioritaires sur les autres opérateurs logiques, l'évaluation de la
condition se déroule comme suit :
1. ($balleTexture === 'lisse' || $balleTexture === 'rugueux') = (true || false) = true
2. (true && $balleCouleur === 'vert') = (true && false) = false
*/
if (($balleTexture === 'lisse' || $balleTexture === 'rugueux') && $balleCouleur === 'vert')
{
echo 'Il s\'agit de la bonne balle !';
}
// N'affichera rien, la condition n'est pas remplie.
?>
Cette fois-ci, avec l'utilisation de parenthèses pour clarifier l'ordre d'évaluation, la condition est évaluée à false comme prévu. D'abord, elle vérifie si $balleTexture est soit 'lisse' ou 'rugueux', puis elle vérifie si $balleCouleur est 'vert'. Cela évite la confusion précédente liée à la priorité des opérateurs logiques.
Lorsque vous êtes confronté à des conditions complexes, il est recommandé d'indenter votre code de la manière suivante pour le rendre plus lisible :
$balleTexture = 'lisse';
$balleCouleur = 'rouge';
if (
($balleTexture === 'lisse' || $balleTexture === 'rugueux')
&& $balleCouleur === 'vert'
)
{
echo 'Il s\'agit de la bonne balle !';
}
// N'affichera rien, la condition n'est pas remplie.
Pour améliorer davantage la lisibilité de votre code, vous pouvez attribuer les conditions à des variables en suivant les conventions de nommage. Cela rendra votre code plus clair et plus compréhensible :
$balleTexture = 'lisse';
$balleCouleur = 'rouge';
// Évaluation logique : tester si la balle est lisse ou rugueuse.
// Le résultat (true ou false) est stocké dans la variable $estLisseOuRugueux.
$estLisseOuRugueux = $balleTexture === 'lisse' || $balleTexture === 'rugueux';
// Afficher le résultat de l'évaluation logique.
var_dump($estLisseOuRugueux); // Affiche : bool(true)
// Évaluation logique : tester si la balle est verte.
$estVert = $balleCouleur === 'vert';
// Afficher le résultat de l'évaluation logique.
var_dump($estVert); // Affiche : bool(false)
// $estLisseOuRugueux vaut true && $estVert vaut false.
// La condition n'est pas remplie (true && false = false).
if ($estLisseOuRugueux && $estVert)
{
echo 'Il s\'agit de la bonne balle !';
}
// N'affichera rien, la condition n'est pas remplie.
L'expression à évaluer dans une structure conditionnelle en PHP ne se limite pas à l'utilisation d'opérateurs de comparaison. Elle peut également inclure toutes les expressions capables de renvoyer une valeur booléenne (true ou false). Par conséquent, vous avez la possibilité d'utiliser des fonctions telles que is_numeric(), qui permet de vérifier si une valeur est numérique indépendamment du type, directement dans une condition :
<?php
$nombreEnfants = readline('Entrez une valeur pour vérifier si elle est numérique :');
// Récupérer le type de la valeur entrée par l'utilisateur.
// Pour rappel readline() retourne toujours une chaîne de caractères.
$nombreEnfantsType = gettype($nombreEnfants);
// Afficher un début de phrase indiquant la valeur entrée par l'utilisateur ainsi que son type.
echo "$nombreEnfants est de type $nombreEnfantsType et sa valeur ";
// La fonction is_numeric() retourne true si la valeur passée en argument est numérique (quel que soit son type).
// Par exemple, si l'utilisateur saisit 5 avec readline, $nombreEnfants contiendra la chaîne "5".
// Comme il s'agit bien d'une valeur numérique, is_numeric() retournera true et le bloc if sera exécuté.
if (is_numeric($nombreEnfants))
{
echo 'est numérique !';
}
else
{
echo 'n\'est pas numérique !';
}
?>
Instruction switch
Abordant maintenant une alternative aux structures de conditions telles que nous venons de les voir ( if...elseif...else ). Il s'agit de la structure switch qui permet d'évaluer une expression ou une variable et de choisir parmi plusieurs cas d'exécution en fonction de la valeur de cette expression. Voici comment il fonctionne :
- Évaluation de l'expression : L'expression à évaluer est spécifiée entre les parenthèses de switch. Cette expression est évaluée une seule fois.
- Correspondance avec les case : Le programme compare la valeur de l'expression à chaque case (cas) spécifié dans la structure switch. Notez qu'il s'agit d'une comparaison non stricte ==, ce qui signifie que le typage n'est pas pris en compte dans la comparaison.
- Exécution du code correspondant : Si une correspondance est trouvée entre la valeur de l'expression et l'une des case (égalité non strict), le bloc de code associé à cette case est exécuté. L'exécution continue jusqu'à ce qu'un break soit rencontré, indiquant la fin du traitement pour ce cas particulier.
- Sortie du switch : Une fois le code d'une case est exécuté et qu'un break y est présent. Si aucun break n'est utilisé, le programme continuera à exécuter le code des case suivants jusqu'à ce qu'il rencontre un break ou atteigne la fin du switch.
- default (optionnel) : Vous pouvez également inclure une section default dans votre structure switch. Si aucune correspondance n'est trouvée entre la valeur de l'expression et les case précédents, le code de la section default sera exécuté.
Voici une conversion de l'exemple sur les années de mariage que nous avions réalisé lorsque nous avons débuter avec elseif :
<?php
$anneeDeMariage = readline('Veuillez entrer le nombre d\'années de mariage à célébrer : ');
switch ($anneeDeMariage)
{
case 0:
echo 'Bien que le temps puisse vous sembler long, la première année de mariage n\'est pas encore passée !';
break;
case 1:
echo 'Félicitations pour les Noces de Coton !';
break;
case 2:
echo 'Félicitations pour les Noces de Cuir !';
break;
default:
echo 'Quel courage ! Vous êtes marié depuis plus de 2 ans !';
}
?>
Finalement, l'utilisation de switch peut rendre le code plus clair lorsque vous avez de nombreuses branches conditionnelles basées sur une valeur unique mais étant moins flexible que la structure if...elseif...else, vous ne devriez pas la rencontrer souvent.
Opérateur Ternaire
L'opérateur ternaire est un outil très utile pour créer des expressions conditionnelles simples de manière concise. Il est également appelé opérateur conditionnel. Cet opérateur permet de réaliser une structure de condition non imbriquée en évaluant une expression conditionnelle et en renvoyant une valeur en fonction de cette condition.
L'opérateur ternaire a la forme suivante :
( condition ) ? valeur a retourner si la condition est vraie : valeur à retourner si la condition est fausse;
Reprenons le premier exemple que nous avions vu lorsque nous avons découvert l'instruction else et convertissons sous cette forme :
<?php
$age = readline('Veuillez entrer l\'âge à tester : ');
$resultat = ($age >= 18) ? 'La personne est majeure !' : 'La personne est mineure !';
echo $resultat;
?>
En réalité, techniquement, il est possible de réaliser des structure imbriquée avec cette opérateur mais pour des raisons de lisibilité, il est vivement déconseillé de le faire.
En PHP, il existe une version encore plus concise de l'opérateur ternaire, appelée "opérateur Elvis". Cet opérateur permet d'attribuer une valeur par défaut à une variable si la valeur principale est évaluée comme falsy. C'est un moyen pratique d'assurer une valeur de secours sans avoir à écrire une condition explicite :
<?php
$texte = "Mon texte de test.";
// $resultat = valeur à tester ?: valeur par défaut si valeur à tester est égale à null, 0 ou false;
$resultat = $texte ?: "!!! VOUS N'AVEZ PAS ENTRÉ DE TEXTE !!!";
echo "Mon texte : $resultat"; // Affiche : Mon texte de test.
?>
Quand on travaille avec des variables potentiellement non définies, l'utilisation de l'opérateur Elvis peut générer un avertissement.
<?php
// Dans cet exemple, la variable "$texte" n'a pas été déclarée, elle est donc indéfinie.
// $resultat = valeur à tester ?: valeur par défaut si valeur à tester est égale à null, 0 ou false;
$resultat = $texte ?: "!!! VOUS N'AVEZ PAS ENTRÉ DE TEXTE !!!";
echo "Mon texte : $resultat"; // Affiche : Warning: Undefined variable $texte in...
?>
Pour pallier ce problème, on peut utiliser l'opérateur de coalescence nulle ??. Cet opérateur permet d'assigner une valeur par défaut uniquement si la variable est null ou si elle n'a pas été définie, sans générer d'avertissement. Contrairement à l'opérateur Elvis, il ne considère pas les autres valeurs falsy comme "vides".
<?php
// Dans cet exemple, la variable "$texte" n'a pas été déclarée, elle est donc indéfinie.
// $resultat = valeur à tester ?: valeur par défaut si valeur à tester est égale à null ou undefined;
$resultat = $texte ?? "!!! VOUS N'AVEZ PAS ENTRÉ DE TEXTE !!!";
echo "Mon texte : $resultat"; // Affiche : !!! VOUS N'AVEZ PAS ENTRÉ DE TEXTE !!!
?>
Exercices
Exo-conditions-01
- Objectif : Vérifier un seuil pour activer une option de livraison gratuite.
- Instructions :
- Créez un fichier exo-conditions-01.php.
- Déclarez une variable $montantCommande à laquelle vous attribuez l'entier 35.
- À l'aide d'une structure if, affichez la phrase "Livraison gratuite activée." uniquement si le montant est supérieur ou égal à 50.
- Exécutez le fichier dans le terminal et vérifiez que rien ne s'affiche avec la valeur actuelle de $montantCommande.
- Modifiez plusieurs fois la valeur de $montantCommande (ex.: 49, 50, 120) afin d'observer à partir de quel montant la livraison devient gratuite.
Exo-conditions-02
- Objectif : Utiliser if...else pour simuler un contrôle de mot de passe.
- Instructions :
- Créez un fichier exo-conditions-02.php.
- Déclarez une variable $motDePasseCorrect contenant un mot de passe attendu (ex.:'Secret123').
- Demandez à l'utilisateur de saisir un mot de passe avec readline() et stockez la saisie dans $motDePasseSaisi.
-
Créez une structure if...else qui affiche :
- "Connexion réussie." lorsque le mot de passe saisi correspond à la valeur attendue.
- "Mot de passe incorrect." dans le cas contraire.
- Testez le script avec un mot de passe correct puis avec un mot de passe incorrect.
Exo-conditions-03
- Objectif : Utiliser if...elseif...else pour interpréter un code de statut HTTP.
- Instructions :
- Créez un fichier exo-conditions-03.php.
- Demandez à l'utilisateur d'entrer un code de statut HTTP avec readline() et stockez la valeur dans $codeHttp.
-
À l'aide de if...elseif...else, affichez un message selon la valeur :
- 200 : "OK : la requête a réussi."
- 301 ou 302 : "Redirection : la ressource a changé d'adresse."
- 404 : "Erreur : ressource introuvable."
- 500 : "Erreur : problème interne du serveur."
- Autre valeur : un message indiquant que le code n'est pas géré par votre script.
- Testez votre script avec plusieurs valeurs ( 200, 301, 302, 404, 500 et 123 ) et observez le message correspondant dans le terminal.
Exo-conditions-04
- Objectif : Comparer l'égalité non stricte == et l'égalité stricte === sur un identifiant d'URL.
- Instructions :
- Créez un fichier exo-conditions-04.php.
- Déclarez une variable $idEnBase contenant la valeur entière 5 qui représente l'identifiant stocké en base de données.
- Demandez à l'utilisateur de saisir un identifiant d'article (nombre entier) avec readline() et stockez la valeur dans $idRequete.
- Utilisez var_dump() pour afficher la valeur et le type de $idRequete et de $idEnBase.
-
Créez une première condition avec l'opérateur non strict
== qui affiche un message différent selon que la comparaison
réussit ou non.
- Si la comparaison avec == réussit affichez le message "Comparaison non stricte réussie, les deux valeurs sont considérées comme égales.".
- Si la comparaison avec == échoue affichez le message "Comparaison non stricte échouée, les deux valeurs ne sont pas considérées comme égales.".
-
Créez ensuite une seconde condition avec l'opérateur strict
=== pour comparer les mêmes variables, avec un autre message.
- Si la comparaison avec === réussit affichez le message "Comparaison stricte réussie, la valeur et le type sont identiques.".
- Si la comparaison avec === échoue affichez le message "Comparaison stricte échouée, la valeur ou le type ne correspond pas.".
- Testez le script en saisissant tour à tour 5, "5" et une valeur totalement différente afin d'observer les résultats des deux comparaisons.
Exo-conditions-05
- Objectif : Observer la conversion implicite en booléens sur un champ de formulaire simulé.
- Instructions :
- Créez un fichier exo-conditions-05.php.
- Déclarez une variable $nombreEnfants qui représente le nombre d'enfants saisi dans un futur formulaire HTML. Donnez-lui d'abord la valeur 0.
-
Écrivez une condition simplifiée
if ($nombreEnfants) qui affiche :
- Si la condition est vraie, affichez le message "Comparaison non stricte réussie : Ce champ est bien rempli.".
- Si la condition est fausse, affichez le message "Comparaison non stricte échoue : Ce champ est requis.".
- Exécutez le script et observez le message obtenu.
-
Ajoutez une seconde condition qui compare
$nombreEnfants à
null avec l'égalité stricte
===.
Cette condition doit afficher exactement :
- Si la comparaison avec $nombreEnfants === null réussit affichez le message "Comparaison stricte réussie : Ce champ est requis.".
- Si la comparaison avec $nombreEnfants === null échoue affichez le message "Comparaison stricte échoue : Ce champ est bien rempli.".
-
Modifiez plusieurs fois la valeur de
$nombreEnfants
(0,
2,
null,
"")
et observez les différences entre :
- la conversion implicite en booléen effectuée dans if ($nombreEnfants),
- la comparaison stricte avec ===.
-
Pour bien comprendre ce que PHP considère comme vrai ou faux, créez ensuite plusieurs variables
booléennes stockant le résultat d'une conversion explicite avec
(bool) pour les valeurs suivantes :
- $nullConvertiEnBool = (bool) null
- $zeroConvertiEnBool = (bool) 0
- $chaineVideConvertieEnBool = (bool) ""
- $nombreConvertiEnBool = (bool) 10
- $chaineConvertieEnBool = (bool) "Bonjour!"
Exo-conditions-06
- Objectif : Combiner plusieurs conditions avec les opérateurs logiques pour contrôler l'accès à une page d'administration.
- Instructions :
- Créez un fichier exo-conditions-06.php.
-
Déclarez trois variables booléennes :
- $estConnecte pour représenter l'état de connexion.
- $estAdmin pour représenter le rôle administrateur.
- $compteSuspendu pour indiquer si le compte est suspendu.
-
À l'aide d'une structure if...else et des opérateurs logiques
&& et !, affichez :
- Si l'utilisateur est connecté, qu'il a le role admin et que le compte n'est pas suspendu, affichez le message "Accès à l'administration autorisé.".
- Dans tous les autres cas, affichez le message "Accès refusé.".
- Testez plusieurs combinaisons de valeurs pour $estConnecte, $estAdmin et $compteSuspendu afin de vérifier le comportement de la condition.
- Ajoutez ensuite une autre condition qui affiche le message "Accès en lecture seule." lorsque l'utilisateur est connecté, qu'il n'a pas le role admin et que le compte n'est pas suspendu.
Exo-conditions-07
- Objectif : Utiliser une structure switch pour gérer différents rôles utilisateurs.
- Instructions :
- Créez un fichier exo-conditions-07.php.
- Demandez à l'utilisateur de saisir un rôle avec readline() et stockez la valeur dans $role. Le texte saisi devra être exactement l'un des mots suivants : "admin", "editor", "user".
-
Créez une structure switch analysant
$role.
Selon le rôle détecté, affichez strictement les phrases suivantes :
- Pour "admin" : "Accès total au système."
- Pour "editor" : "Accès limité : modification du contenu autorisée."
- Pour "user" : "Accès restreint : consultation uniquement."
- Ajoutez ensuite un bloc default qui affiche exactement : "Erreur : rôle inconnu."
- Testez le script en saisissant successivement : "admin", "editor", "user", puis un rôle non prévu comme "test" afin de vérifier que chaque message s'affiche correctement.
-
Retirez maintenant volontairement le break du
case correspondant à "editor".
Exécutez à nouveau le script et saisissez "editor".
Vous devez observer que le programme affiche le message prévu pour "editor", puis continue d'exécuter le case suivant jusqu'à rencontrer un break ou jusqu'à sortir complètement du switch. - Replacez le break manquant afin de rétablir le comportement normal de la structure switch.
Exo-conditions-08
- Objectif : Utiliser l'opérateur ternaire pour déterminer un label à partir d'un nombre de points de fidélité.
- Instructions :
- Créez un fichier exo-conditions-08.php.
- Demandez à l'utilisateur d'entrer son nombre de points de fidélité avec readline() et stockez la valeur dans $points.
-
Créez une variable
$label.
Attribuez-lui ensuite une valeur en utilisant une structure
if...else.
Selon le résultat de votre condition,
$label doit recevoir précisément :
- "Client standard" si le nombre de points est inférieur à 100.
- "Client premium" dans le cas contraire.
- Commentez ensuite cette structure if...else et réécrivez la même logique en une seule ligne avec un opérateur ternaire, toujours en stockant le résultat dans $label.
- Vérifiez que le comportement reste identique en testant plusieurs valeurs (ex.: 50, 100, 250).
Exo-conditions-09
- Objectif : Utiliser l'opérateur de coalescence nulle ?? pour définir une valeur par défaut.
- Instructions :
- Créez un fichier exo-conditions-09.php.
-
Créez une variable $langActive en utilisant l'opérateur de coalescence
nulle ??.
$langActive doit prendre :- la valeur de $lang si cette variable existe et ne vaut pas null,
- la valeur "fr" dans tous les autres cas.
- Affichez dans le terminal une phrase construite en concaténation implicite qui utilise la variable $langActive. Le texte attendu pour ce premier test est : "Langue active : fr".
- Ajoutez ensuite une déclaration de variable $lang dans votre script en lui donnant la valeur "en". Veillez à ce que cette déclaration soit interprétée avant l'utilisation de $langActive.
- Réexécutez le script et vérifiez que le message affiché devient : "Langue active : en".