Créer des conditions robustes avec les opérateurs logiques

Dans cette nouvelle leçon, nous allons apprendre à créer des conditions complexes qui vont utiliser plusieurs comparaisons grâce aux opérateurs logiques.

 

Imbriquer plusieurs conditions

Souvent, nous allons vouloir comparer plusieurs valeurs au sein d’une même condition, c’est-à-dire n’exécuter son code que si plusieurs conditions sont vérifiées.

Pour faire cela, nous allons pouvoir soit utiliser les opérateurs logiques, soit imbriquer plusieurs conditions les unes dans les autres.

Les opérateurs logiques vont nous permettre de créer des conditions plus puissantes mais dans certains cas il sera plus intéressant et plus rapide d’imbriquer des conditions.

<!DOCTYPE html>
<html>
    <head>
        <title>Cours PHP & MySQL</title>
        <meta charset="utf-8">
        <link rel="stylesheet" href="cours.css">
    </head>
    
    <body>
        <h1>Titre principal</h1>
        <?php
            $inscrit = true;
            $age = 21;
            
            if($inscrit){
                if($age >= 18){
                    echo 'Utilisateur inscrit et majeur, accès autorisé';
                }else{
                    echo 'Utilisateur inscrit et mineur, accès restreint';
                }
            }else{
                echo 'Utilisateur non inscrit, accès refusé';
            }
        ?>
        <p>Un paragraphe</p>
    </body>
</html>

 

Exemple d'imbrication de conditions en PHP et résultat

Dans cet exemple, on veut tester les critères « utilisateur inscrit ou non » et « utilisateur majeur ou non » et répondre de façon différente en fonction de chaque situation.

La façon la plus simple de faire cela est de créer une première condition if…else et d’imbriquer une deuxième condition if…else à l’intérieur du premier if.

Le PHP va d’abord évaluer la comparaison du premier if. Si le test est validé, on entre alors dans le deuxième if et on évalue la condition de celui-ci. Si le test du premier if échoue, alors on passe directement au else sans jamais rentrer dans le deuxième if…else.

Notez par ailleurs que comme dans notre cas notre variable $inscrit stocke une valeur booléenne on n’a pas besoin de faire de comparaison explicite puisque la valeur true est elle-même évaluée à true tandis que false est évaluée à false par le PHP.

 

Présentation des opérateurs logiques

Les opérateurs logiques vont être principalement utilisés avec les conditions puisqu’ils vont nous permettre d’écrire plusieurs comparaisons au sein d’une même condition ou encore d’inverser la valeur logique d’un test.

En PHP, nous pouvons utiliser les opérateurs logiques suivants :

OpérateurDéfinition
ANDRenvoie true si toutes les comparaisons valent true
&&Renvoie true si toutes les comparaisons valent true
ORRenvoie true si une des comparaisons vaut true
||Renvoie true si une des comparaisons vaut true
XORRenvoie true si une des comparaisons exactement vaut true
!Renvoie true si la comparaison vaut false (et inversement)

Comme vous pouvez le constater, les opérateurs logiques « ET » et « OU » peuvent s’écrire de deux façons différentes : soit avec les mots clefs AND et OR, soit avec les signes && et ||.

Ces deux écritures ne sont pas tout à fait équivalentes : la différence réside dans l’ordre des priorités de traitement des opérations. En effet, l’écriture avec des signes a une priorité plus importante que l’écriture avec des mots clefs.

Attention également à ne pas confondre les opérateurs logiques OR et XOR en PHP : si on utilise l’opérateur OR, le PHP va renvoyer true si au moins une des comparaisons vaut true et renverra donc true si plusieurs comparaisons valent true tandis qu’en utilisant l’opérateur XOR le PHP ne renverra true que si une seule comparaison vaut true (et reverra false si plusieurs comparaisons valent true).

 

Récapitulatif : l’ordre de priorité des opérateurs

Au cours des leçons précédentes, nous avons vu les types d’opérateurs les plus communs : opérateurs arithmétiques, d’affectation, de chaine, de comparaison et maintenant logiques.

Les seuls types d’opérateurs communs que nous n’avons pas encore étudié sont les opérateurs d’incrémentation et de décrémentation ainsi que l’opérateur ternaire.

A ce niveau du cours, il me semble donc important de faire un récapitulatif global de la priorité de tous ces opérateurs et de leur associativité afin de pouvoir les utiliser de la meilleure manière.

La tableau suivant liste les différents opérateurs vus jusqu’ici ainsi que les opérateurs d’incrémentation et de décrémentation et le ternaire qu’on étudiera plus tard selon leur priorité (la première ligne du tableau contient les opérateurs avec la plus grande priorité et etc. jusqu’à la dernière ligne contenant les opérateurs avec la plus petite priorité).

OpérateursAssociativité
**droite
++ (incrémentation), -- (décrémentation)droite
!droite
*, /, %gauche
+, -, .gauche
<, <=, >, >=non-associatif
==, ===, !=, !==, <>, <=>non-associatif
&&gauche
||gauche
??droite
? : (ternaire)gauche
=, +=, -=, *=, /=, %=, **=, .=droite
ANDgauche
XORgauche
ORgauche

Je sais que ça fait beaucoup de choses à retenir et que ce genre de choses ne fait pas partie des choses les plus marrantes ou intéressantes à apprendre à priori. Cependant, connaitre la priorité des opérateurs est indispensable pour bien les utiliser et nous allons beaucoup utiliser les opérateurs en PHP.

Je vous demande donc ici de faire votre maximum pour ne pas directement « passer à la suite » mais plutôt pour prendre le temps de comprendre et de retenir ces différentes priorités et l’associativité des différents opérateurs.

 

Utilisation des opérateurs logiques avec les conditions

Une condition avec plusieurs comparaisons

Les opérateurs logiques AND, &&, OR, || et XOR vont nous permettre de créer des conditions avec plusieurs comparaisons.

On va ainsi pouvoir choisir d’exécuter un code uniquement si toutes les comparaisons valent true, ou si au moins l’une d’entre elles vaut true, ou encore si seulement l’une d’entre elles vaut true.

<!DOCTYPE html>
<html>
    <head>
        <title>Cours PHP & MySQL</title>
        <meta charset="utf-8">
        <link rel="stylesheet" href="cours.css">
    </head>
    
    <body>
        <h1>Titre principal</h1>
        <?php
            $x = 4; //On affecte la valeur 4 à $x
            $y = -12; //On affecte la valeur -12 à $y
            
            if($x >= 0 AND $x <= 5){
                echo '$x contient une valeur entre 0 et 5 <br>';
            }
            
            if($x >= 0 AND $y >= 0){
                echo '$x et $y contiennent une valeur positive <br>';
            }
            
            if($x >= 0 OR $y >= 0){
                echo '$x ou $y (ou les deux) contient une valeur positive <br>';
            }
            
            if($x >= 0 XOR $y >= 0){
                echo '$x ou $y contient une valeur positive mais pas les deux';
            }
        ?>
        <p>Un paragraphe</p>
    </body>
</html>

 

On utilise les opérateurs logiques au sein de nos conditions PHP

Dans l’exemple ci-dessus, notre première condition utilise l’opérateur AND. Chacune des deux comparaisons va devoir être évaluée à true pour que le code de la condition soit exécuté.

Notre deuxième condition est équivalente dans sa structure à la première. LA seule différence est qu’on effectue deux comparaisons avec deux variables différentes.

Notre troisième condition utilise l’opérateur OR. Dans ce cas, il suffit qu’une comparaison soit évaluée à true pour que le code de notre condition soit exécuté.

Notre dernière condition utilise elle l’opérateur XOR. Pour que le code de la condition soit exécuté, il va falloir ici qu’une comparaison exactement soit évaluée à true.

De plus, on va tout à fait pouvoir utiliser plusieurs opérateurs logiques dans une même condition pour ajouter des règles et des comparaisons à celle-ci. Il faudra ici faire bien attention à la priorité des différents opérateurs pour obtenir le résultat voulu ou utiliser des parenthèses pour forcer la priorité de certains opérateurs par rapport à d’autres.

<!DOCTYPE html>
<html>
    <head>
        <title>Cours PHP & MySQL</title>
        <meta charset="utf-8">
        <link rel="stylesheet" href="cours.css">
    </head>
    
    <body>
        <h1>Titre principal</h1>
        <?php
            $x = 4; //On affecte la valeur 4 à $x
            $y = -12; //On affecte la valeur -12 à $y
            $z = 1; //On affecte la valeur 1 à $z
            
            if($x >= 0 AND $x <= 5 AND $y <= 0){
                echo '$x contient une valeur entre 0 et 5 et $y contient une valeur
                négative <br>';
            }
            
            if($x >= 0 AND $y >= 0 XOR $z >= 0){
                echo '$x et $y contiennent tous les deux une valeur positive et $z
                une valeur stric. négative ou le contraire<br>';
            }
            
            if($x >= 0 AND ($y >= 0 XOR $z >= 0)){
                echo '$x contient une valeur positive et soit $y, soit $z contient
                une valeur positive mais pas les deux <br>';
            }
        ?>
        <p>Un paragraphe</p>
    </body>
</html>

 

La priorité des opérateurs logiques dans les conditions en PHP

Pour comprendre comment fonctionnent les conditions ci-dessus, il faut savoir que l’opérateur AND possède une priorité plus importante que XOR.

Notre première condition utilise deux opérateurs AND. Ici, c’est relativement simple : il va falloir que chacune des trois comparaisons soit évaluée à true pour que le code dans notre condition soit exécuté.

Notre deuxième condition utilise les opérateurs AND et XOR. L’opérateur AND a la priorité sur XOR et donc le test va être analysé comme suivant : on va d’abord tester si $x et $y contiennent toutes les deux une valeur positive puis on va tester si $z contient une valeur négative.

Si l’un de ces deux tests et seulement l’un d’entre eux renvoie true, alors le code de la condition est exécuté.

Dans notre troisième condition, on utilise cette fois-ci des parenthèses pour imposer la priorité des opérations. Ici, on va tester d’un côté si $x contient une valeur positive et renvoyer true si c’est le cas puis si $y ou $z possèdent une valeur positive et renvoyer true si c’est le cas pour seulement l’une des deux variables. Si nos deux tests renvoient true et true, le code dans la condition sera exécuté.

Inverser la valeur logique d’une variable, d’une condition ou d’un test

L’opérateur logique inverse ! va nous permettre d’inverser la valeur logique d’une variable, d’une condition ou d’un test. Grosso modo, cela signifie qu’à chaque fois que le PHP va évaluer quelque chose à true à false, l’opérateur ! va inverser cette valeur (true va devenir false et inversement).

Cet opérateur va donc très simplement nous permettre d’exécuter le code de nos conditions lorsque le test de la condition a échoué (c’est-à-dire lorsque PHP renvoie false).

<!DOCTYPE html>
<html>
    <head>
        <title>Cours PHP & MySQL</title>
        <meta charset="utf-8">
        <link rel="stylesheet" href="cours.css">
    </head>
    
    <body>
        <h1>Titre principal</h1>
        <?php
            $x = 4; //On affecte la valeur 4 à $x
            $y = -12; //On affecte la valeur -12 à $y
            
            if(!$x >= 0 AND !$y >= 0){
                echo 'Ce texte est toujours affiché !<br>';
            }
            
            if(!($x >= 0) AND !($y >= 0)){
                echo 'Ce texte s\'affiche uniquement si $x et $y contiennent
                toutes les deux une valeur stric. négative <br>';
            }
            
             if(!($x >= 0 AND $y >= 0)){
                echo 'Soit $x contient une valeur stric. négative, soit $y
                contient une valeur stric. négative, soit les deux variables
                contiennent une valeur stric. négative';
            }
        ?>
        <p>Un paragraphe</p>
    </body>
</html>

 

L'opérateur logique inverse et le transtypage en PHP

Pour comprendre les résultats ci-dessus, il convient à nouveau de bien connaitre les priorités des opérateurs.

Dans le cas présent, l’opérateur ! a une priorité plus importante que les autres opérateurs logiques et que les opérateurs de comparaison.

Le résultat de notre première condition est peut-être le moins évident à comprendre car de nombreux mécanismes entrent en jeu ici. Essayons d’expliquer ce qu’il se passe.

Dans notre première condition, nous plaçons l’opérateur ! devant nos deux variables $x et $y sans utiliser de parenthèses. Ici, il faut bien comprendre que PHP va commencer par évaluer !$x et !$y et renvoyer un booléen (true ou false).

L’opérateur logique ! inverse une valeur logique, c’est-à-dire transforme true en false et false en true.

Le PHP va donc déjà effectuer un transtypage et commencer par évaluer les valeurs de $x et $y en termes booléen pour ensuite pouvoir inverser la valeur obtenue.

Ici, vous devez savoir que lors d’une conversion en booléen, seules les valeurs suivantes sont évaluées à false :

  • Le booléen false lui-même ;
  • Le chiffre 0 ;
  • La chaine de caractères vide et la chaine de caractères « 0 » ;
  • Le type NULL ;
  • Un tableau vide.

Toute autre valeur est évaluée à true.

La variable $x contient 4 tandis que $y contient -12. En termes booléen, les deux variables vont être évaluées à true et donc !$x et !$y vont renvoyer false.

Ensuite, on va comparer les valeurs obtenues à 0 avec l’opérateur >= pour nos deux variables. Ici, le PHP va effectuer un nouveau transtypage et convertir les valeurs booléennes obtenues en entier. La booléen false évalué comme entier est égal à 0 (true est égal à 1).

Or, 0 est bien supérieur ou égal à 0 et donc !$x >= 0 et !$y >= 0 sont évalués à true et donc notre test renvoie finalement true.

Dans ce premier cas, le test ne peut finalement jamais renvoyer false puisque quelles que soient les valeurs de $x et $y ces variables vont d’abord être évaluées en termes booléen et donc l’inverse (qui sera l’autre booléen) sera toujours soit true soit false qui, une fois trantypées en entiers, donneront 1 ou 0 qui est bien dans tous les cas supérieur ou égal à 0.

Ce premier exemple, je vous rassure, était complexe et particulièrement à votre niveau mais il permet de bien comprendre comment l’opérateur ! fonctionne et comment PHP évalue les variables selon les opérateurs.

Dans notre deuxième condition, on utilise cette fois-ci des parenthèses pour indiquer que les comparaisons $x >= 0 et $y >= 0 doivent être évaluées avant d’inverser la valeur logique obtenue.

Ici, $x >= 0 renvoie true puisque 4 est bien supérieur à 0 et $y >= 0 renvoie false puisque -12 est strictement inférieur à 0. Ces deux valeurs sont ensuite inversées et on obtient if(false AND true) qui est évalué à false.

Dans notre troisième et dernière condition, on inverse le résultat final des comparaisons. Ici, on a toujours $x >= 0 qui renvoie true et $y >= 0 qui renvoie false et donc $x >= 0 AND $y >= 0 qui renvoie false. On inverse ensuite la valeur logique et on obtient finalement true.

Laisser un commentaire