PhpBB Lab Académie

Continuer dans le même fichier index.php avec les booléens déjà présents dans le fil rouge, comprendre le rôle des opérateurs logiques &&, || et !, apprendre à combiner plusieurs conditions sans perdre leur sens, créer un booléen conversionEnCours plus précis et préparer la construction de conditions complexes et lisibles dans la leçon suivante.

Avant de commencer

Dans la leçon précédente, nous avons appris à gérer plus de deux chemins avec :

if
elseif
else

Le dossier du fil rouge contient toujours notamment :

index.html
index.php
apropos.html
contact.html
ordinateur.jpg
styles.css

Au début de :

index.php

nous pouvons maintenant avoir :

<?php
$nomSite = 'Mon premier site HTML';
$nombrePages = 3;
$pagesConvertiesPhp = 1;
$pagesRestantes = $nombrePages - $pagesConvertiesPhp;
$messageAccueil = 'Le site possède ' . $nombrePages . ' pages principales et il reste ' . $pagesRestantes . ' pages à faire évoluer vers PHP.';

$progressionCommencee = $pagesConvertiesPhp > 0;
$conversionTerminee = $pagesRestantes === 0;

if ($conversionTerminee)
{
    $messageConversion = 'La conversion PHP du site est terminée.';
}
elseif ($progressionCommencee)
{
    $messageConversion = 'La conversion PHP du site est en cours : ' . $pagesRestantes . ' pages restent à faire évoluer.';
}
else
{
    $messageConversion = 'La conversion PHP du site n’a pas encore commencé.';
}

$formulaireTraite = false;
$formulaireEnAttente = $formulaireTraite === false;

$dernierMessage = null;
$aucunMessage = $dernierMessage === null;
?>

Nous disposons donc déjà de plusieurs booléens :

$progressionCommencee
$conversionTerminee
$formulaireEnAttente
$aucunMessage

Jusqu’à présent, nous les utilisons séparément.

Mais certaines décisions ont besoin de plusieurs informations à la fois.

Dans cette deuxième leçon du chapitre, nous allons répondre à quatre questions :

- Comment demander que deux conditions soient vraies en même temps ?
- Comment accepter qu’au moins une condition soit vraie ?
- Comment inverser un booléen ?
- Comment construire une condition combinée qui reste lisible ?

À la fin de cette leçon, nous aurons un nouveau booléen :

$conversionEnCours

qui exprimera précisément :

la progression a commencé
ET
la conversion n’est pas terminée

1. Qu’est-ce qu’un opérateur logique ?

Un opérateur logique permet de combiner ou de transformer des valeurs booléennes.

Nous allons apprendre trois opérateurs :

&&
||
!

Nous les lirons ainsi :

&&
= ET

||
= OU

!
= NON

Ils travaillent avec des expressions qui produisent :

true

ou :

false

2. Reprendre nos booléens existants

Avec l’état actuel :

$pagesConvertiesPhp = 1;

nous avons :

$progressionCommencee = true;
$conversionTerminee = false;
$formulaireEnAttente = true;
$aucunMessage = true;

Nous n’inventons donc pas de nouvelles données pour apprendre les opérateurs logiques.

Nous allons combiner des booléens qui existent déjà dans le fil rouge.

3. Découvrir l’opérateur &&

L’opérateur :

&&

signifie :

ET

L’expression complète est vraie uniquement si les deux conditions sont vraies.

Nous pouvons représenter le principe ainsi :

true && true
= true

true && false
= false

false && true
= false

false && false
= false

Les deux côtés doivent donc être vrais.

4. Premier test avec &&

Nous avons actuellement :

$progressionCommencee = true;

$formulaireEnAttente = true;

Testez temporairement :

$testEt = $progressionCommencee && $formulaireEnAttente;

Les deux valeurs sont vraies.

Le résultat est donc :

true

5. Vérifier avec var_dump()

Ajoutez temporairement :

var_dump($testEt);

Vous devez obtenir :

bool(true)

selon la présentation produite par PHP.

Supprimez ensuite :

var_dump($testEt);

et la variable :

$testEt

Cette première expérience sert seulement à comprendre

&&

.

6. Observer && lorsqu’une condition est fausse

Nous avons :

$conversionTerminee = false;

$formulaireEnAttente = true;

Testez temporairement :

$testEt = $conversionTerminee && $formulaireEnAttente;

L’une des deux valeurs est fausse.

Le résultat est donc :

false

Nous retrouvons la règle :

ET
= les deux conditions doivent être vraies

7. Découvrir l’opérateur ||

L’opérateur :

||

signifie :

OU

L’expression est vraie si au moins une des deux conditions est vraie.

Nous pouvons représenter :

true || true
= true

true || false
= true

false || true
= true

false || false
= false

Le résultat n’est faux que lorsque les deux côtés sont faux.

8. Premier test avec ||

Nous avons :

$conversionTerminee = false;

$progressionCommencee = true;

Testez temporairement :

$testOu = $conversionTerminee || $progressionCommencee;

Même si la première valeur est fausse,

la seconde est vraie.

Le résultat est donc :

true

9. Comprendre le sens de OU

Dans cette expression :

$conversionTerminee || $progressionCommencee

nous demandons :

la conversion est-elle terminée
OU
la progression a-t-elle commencé ?

Il suffit qu’une réponse soit vraie pour que l’ensemble produise :

true

Supprimez ensuite la variable de test.

10. Découvrir l’opérateur !

L’opérateur :

!

signifie :

NON

Il inverse une valeur booléenne.

Nous pouvons représenter :

!true
= false

!false
= true

Contrairement à

&&

et

||

,

il s’applique ici à une seule valeur.

11. Inverser conversionTerminee

Nous avons actuellement :

$conversionTerminee = false;

Testez :

$conversionNonTerminee = !$conversionTerminee;

Comme nous inversons :

false

le résultat est :

true

Nous pouvons lire :

la conversion n’est pas terminée
= vrai

12. Le signe ! ne modifie pas la variable d’origine

Lorsque nous écrivons :

!$conversionTerminee

nous n’attribuons pas une nouvelle valeur à :

$conversionTerminee

Nous produisons une nouvelle valeur booléenne.

La variable d’origine reste :

false

C’est l’expression :

!$conversionTerminee

qui produit :

true

13. Créer un booléen utile : conversionEnCours

Nous voulons maintenant définir précisément ce que signifie :

conversion en cours

Pour que la conversion soit en cours :

- elle doit avoir commencé ;
- elle ne doit pas être terminée.

Nous pouvons donc écrire :

$conversionEnCours = $progressionCommencee && !$conversionTerminee;

Cette variable combine :

ET

et

NON

14. Lire conversionEnCours en français

Reprenons :

$conversionEnCours = $progressionCommencee && !$conversionTerminee;

Nous pouvons lire :

la conversion est en cours
si

la progression a commencé
ET
la conversion n’est PAS terminée

Avec l’état actuel :

$progressionCommencee = true;

$conversionTerminee = false;

nous obtenons :

true && !false

puis :

true && true

et finalement :

true

15. Pourquoi ce booléen est plus précis

Dans la leçon précédente, notre

elseif

utilisait :

$progressionCommencee

Cette logique fonctionnait parce que nous testions :

$conversionTerminee

avant.

Mais le nom :

$conversionEnCours

exprime directement le cas que nous voulons représenter.

Il signifie précisément :

commencée
mais
pas terminée

Le code devient donc plus explicite.

16. Faire évoluer le elseif

Nous pouvons maintenant remplacer :

elseif ($progressionCommencee)

par :

elseif ($conversionEnCours)

La structure devient :

if ($conversionTerminee)
{
    $messageConversion = 'La conversion PHP du site est terminée.';
}
elseif ($conversionEnCours)
{
    $messageConversion = 'La conversion PHP du site est en cours : ' . $pagesRestantes . ' pages restent à faire évoluer.';
}
else
{
    $messageConversion = 'La conversion PHP du site n’a pas encore commencé.';
}

17. Vérifier les trois états avec conversionEnCours

Si :

$pagesConvertiesPhp = 0;

alors :

$progressionCommencee = false;
$conversionTerminee = false;
$conversionEnCours = false;

PHP choisit :

else

Si :

$pagesConvertiesPhp = 1;

alors :

$progressionCommencee = true;
$conversionTerminee = false;
$conversionEnCours = true;

PHP choisit :

elseif

Si :

$pagesConvertiesPhp = 3;

alors :

$conversionTerminee = true;
$conversionEnCours = false;

PHP choisit :

if

18. Pourquoi conversionEnCours devient false à la fin

Avec :

$pagesConvertiesPhp = 3;

nous avons :

$progressionCommencee = true;
$conversionTerminee = true;

Donc :

$conversionEnCours = true && !true;

L’opérateur

!

transforme :

true

en :

false

Nous obtenons donc :

true && false
= false

Une conversion terminée n’est plus considérée comme :

en cours

19. Réutiliser || dans un cas réel

Nous pouvons maintenant construire une information générale :

$projetAEncoreDesEtapes = !$conversionTerminee || $formulaireEnAttente;

Nous pouvons lire :

le projet a encore des étapes
si

la conversion n’est pas terminée
OU
le formulaire est encore en attente

Avec l’état actuel, les deux côtés sont vrais.

Le résultat est donc :

true

20. Pourquoi utiliser OU ici ?

Pour que :

$projetAEncoreDesEtapes

soit vrai,

il suffit qu’au moins une partie du projet nécessite encore du travail.

Nous ne demandons donc pas que les deux conditions soient obligatoirement vraies.

Nous utilisons :

OU

et non :

ET

21. Ne pas confondre ET et OU

Comparez :

$progressionCommencee && $formulaireEnAttente

avec :

$progressionCommencee || $formulaireEnAttente

Dans le premier cas :

les deux conditions doivent être vraies

Dans le second :

au moins une condition doit être vraie

Le choix de l’opérateur dépend donc du sens de la question.

22. Les parenthèses peuvent rendre une expression plus claire

Nous pouvons écrire :

$conversionEnCours = $progressionCommencee && !$conversionTerminee;

Cette expression reste courte.

Mais lorsque plusieurs opérateurs sont combinés,

les parenthèses peuvent rendre le raisonnement plus évident.

Nous pourrions écrire :

$conversionEnCours = $progressionCommencee && (!$conversionTerminee);

Le résultat est le même.

Les parenthèses montrent clairement que :

!

s’applique à :

$conversionTerminee

23. Ne pas construire une expression illisible

Il serait possible d’enchaîner de nombreux opérateurs dans une seule ligne.

Nous éviterons ce type de code lorsque le sens devient difficile à suivre.

Par exemple, au lieu d’accumuler plusieurs tests directement dans un

if

,

nous pouvons créer un booléen nommé :

$conversionEnCours

puis écrire :

elseif ($conversionEnCours)

Nous donnons ainsi un nom au raisonnement.

24. Un booléen nommé peut simplifier une condition

Comparez :

elseif ($progressionCommencee && !$conversionTerminee)

et :

elseif ($conversionEnCours)

Les deux peuvent représenter la même logique.

Mais la deuxième écriture est plus facile à lire si :

$conversionEnCours

a été défini clairement juste avant.

Nous continuerons à privilégier les noms explicites lorsque cela aide la compréhension.

25. Conserver les autres booléens

Nous gardons également :

$formulaireEnAttente
$aucunMessage

Ils ne sont pas encore utilisés pour traiter réellement :

contact.html

Le formulaire reste inchangé.

Nous conservons simplement ces booléens pour apprendre à construire une logique plus riche avant d’aborder le traitement des requêtes.

26. État final du bloc PHP

À la fin de cette leçon, le début de :

index.php

peut devenir :

<?php
$nomSite = 'Mon premier site HTML';
$nombrePages = 3;
$pagesConvertiesPhp = 1;
$pagesRestantes = $nombrePages - $pagesConvertiesPhp;
$messageAccueil = 'Le site possède ' . $nombrePages . ' pages principales et il reste ' . $pagesRestantes . ' pages à faire évoluer vers PHP.';

$progressionCommencee = $pagesConvertiesPhp > 0;
$conversionTerminee = $pagesRestantes === 0;
$conversionEnCours = $progressionCommencee && !$conversionTerminee;

if ($conversionTerminee)
{
    $messageConversion = 'La conversion PHP du site est terminée.';
}
elseif ($conversionEnCours)
{
    $messageConversion = 'La conversion PHP du site est en cours : ' . $pagesRestantes . ' pages restent à faire évoluer.';
}
else
{
    $messageConversion = 'La conversion PHP du site n’a pas encore commencé.';
}

$formulaireTraite = false;
$formulaireEnAttente = $formulaireTraite === false;

$dernierMessage = null;
$aucunMessage = $dernierMessage === null;

$projetAEncoreDesEtapes = !$conversionTerminee || $formulaireEnAttente;
?>

Dans le contenu principal, nous conservons :

<p><?php echo $messageAccueil; ?></p>
<p><?php echo $messageConversion; ?></p>

27. Vérifier l’état réel du fil rouge

À la fin de la leçon :

$pagesConvertiesPhp = 1;

Nous devons donc avoir :

$pagesRestantes = 2;
$progressionCommencee = true;
$conversionTerminee = false;
$conversionEnCours = true;
$formulaireEnAttente = true;
$aucunMessage = true;
$projetAEncoreDesEtapes = true;

Le message de conversion reste :

La conversion PHP du site est en cours : 2 pages restent à faire évoluer.

28. Les opérateurs logiques produisent encore des booléens

Nous n’avons pas changé de type de raisonnement.

Les expressions :

$progressionCommencee && !$conversionTerminee

!$conversionTerminee || $formulaireEnAttente

produisent toujours :

true

ou :

false

Nous combinons simplement plusieurs valeurs booléennes déjà comprises.

29. Préparer des conditions encore plus lisibles

Nous savons maintenant utiliser :

&&
||
!

Mais lorsque plusieurs opérateurs apparaissent ensemble,

une nouvelle difficulté peut surgir :

dans quel ordre faut-il lire l’expression ?

Nous devons également décider quand créer un booléen intermédiaire,

quand utiliser des parenthèses,

et quand séparer une décision en plusieurs étapes.

30. Préparer la prochaine étape

Dans la prochaine leçon, nous terminerons ce chapitre en construisant des conditions plus complètes sans perdre la lisibilité.

Nous reprendrons notamment :

$conversionEnCours
$formulaireEnAttente
$aucunMessage
$projetAEncoreDesEtapes

Nous apprendrons à :

- regrouper clairement des conditions avec des parenthèses ;
- éviter les expressions trop difficiles à relire ;
- choisir entre une condition combinée et plusieurs étapes ;
- vérifier le résultat de chaque partie avant de construire la décision finale.

Nous ne passerons aux tableaux qu’après cette synthèse des conditions.

31. Ce que vous devez comprendre avant la prochaine leçon

Vous devez maintenant être capable d’expliquer :

- ce qu’est un opérateur logique ;
- le rôle de

&&

;
- quand une expression avec

&&

produit

true

;
- le rôle de

||

;
- quand une expression avec

||

produit

false

;
- le rôle de

!

;
- pourquoi

!false

produit

true

;
- pourquoi

!$conversionTerminee

ne modifie pas la variable d’origine ;
- comment nous construisons

$conversionEnCours

;
- pourquoi

$conversionEnCours

vaut

true

avec l’état actuel ;
- pourquoi elle vaut

false

lorsque la conversion est terminée ;
- pourquoi

$projetAEncoreDesEtapes

utilise

||

;
- pourquoi un booléen bien nommé peut rendre une condition plus lisible.

Retenez surtout :

A && B
= A ET B doivent être vrais

A || B
= A OU B : au moins un doit être vrai

!A
= NON A : inverser le booléen

Dans la prochaine leçon, nous utiliserons ces opérateurs pour construire des conditions plus complexes tout en gardant un code lisible et explicable.

Nous avons déjà :

$progressionCommencee = $pagesConvertiesPhp > 0;
$conversionTerminee = $pagesRestantes === 0;

Nous pouvons maintenant écrire :

$conversionEnCours = $progressionCommencee && !$conversionTerminee;

Avec l’état réel :

$progressionCommencee = true;
$conversionTerminee = false;

PHP évalue :

true && !false

puis :

true && true

Le résultat est :

true

Nous pouvons ensuite utiliser :

elseif ($conversionEnCours)

dans la chaîne de décision.

Nous pouvons également exprimer une règle générale :

$projetAEncoreDesEtapes = !$conversionTerminee || $formulaireEnAttente;

Le résultat reste un booléen.

Continuez dans le même fichier :

index.php

1. Conserver les booléens existants

Vérifiez que vous avez :

$progressionCommencee = $pagesConvertiesPhp > 0;
$conversionTerminee = $pagesRestantes === 0;
$formulaireEnAttente = $formulaireTraite === false;
$aucunMessage = $dernierMessage === null;

2. Tester &&

Créez temporairement :

$testEt = $progressionCommencee && $formulaireEnAttente;

Vérifiez le résultat avec

var_dump()

, puis supprimez cette variable.

3. Tester ||

Créez temporairement :

$testOu = $conversionTerminee || $progressionCommencee;

Vérifiez le résultat, puis supprimez cette variable.

4. Tester !

Créez temporairement :

$conversionNonTerminee = !$conversionTerminee;

Vérifiez que la valeur est

true

, puis supprimez cette variable de test.

5. Créer conversionEnCours

Ajoutez durablement :

$conversionEnCours = $progressionCommencee && !$conversionTerminee;

6. Faire évoluer le elseif

Remplacez :

elseif ($progressionCommencee)

par :

elseif ($conversionEnCours)

7. Créer projetAEncoreDesEtapes

Ajoutez :

$projetAEncoreDesEtapes = !$conversionTerminee || $formulaireEnAttente;

8. Vérifier les trois états de conversion

Testez temporairement :

$pagesConvertiesPhp = 0;
$pagesConvertiesPhp = 1;
$pagesConvertiesPhp = 3;

une valeur à la fois.

Vérifiez notamment la valeur de :

$conversionEnCours

dans chaque situation.

Remettez ensuite :

$pagesConvertiesPhp = 1;

9. Expliquer ce que vous avez fait

Sans regarder la correction, expliquez avec vos propres mots :

1. ce que signifie

&&

;
2. ce que signifie

||

;
3. ce que signifie

!

;
4. pourquoi

$conversionEnCours

utilise à la fois

&&

et

!

;
5. pourquoi

$projetAEncoreDesEtapes

utilise

||

;
6. pourquoi le

elseif

est maintenant plus explicite ;
7. pourquoi la prochaine leçon devra s’intéresser à la lisibilité des conditions complexes.

Dans cette leçon, nous avons appris à combiner des valeurs booléennes avec les opérateurs logiques.

Nous avons découvert :

&&
= ET

||
= OU

!
= NON

Nous avons retenu :

A && B
= les deux doivent être vrais

A || B
= au moins un doit être vrai

!A
= inverser le booléen

Dans le fil rouge, nous avons créé :

$conversionEnCours = $progressionCommencee && !$conversionTerminee;

Cette variable exprime précisément qu’une conversion a commencé mais n’est pas encore terminée.

Nous avons aussi créé :

$projetAEncoreDesEtapes = !$conversionTerminee || $formulaireEnAttente;

pour exprimer qu’il reste encore au moins une étape dans le projet.

La chaîne :

if
elseif
else

utilise désormais :

$conversionTerminee

puis

$conversionEnCours

Le fil rouge reste dans son état réel :

$pagesConvertiesPhp = 1;

Dans la prochaine leçon, nous terminerons le chapitre en apprenant à regrouper et organiser des conditions plus complexes avec des parenthèses et des booléens intermédiaires, avant d’ouvrir le chapitre consacré aux tableaux.