[Plan du site]
Vous êtes ici ---
> Le Site du Zéro
> Les tutoriels
> Non-Officiels
> Site Web
> PHP
> Langage, bibliothèques et fonctions
> [Langage] Amusons-nous avec PHP > Les bases du langage > Les structures de contrôles
> Lecture du tutoriel
Les structures de contrôles
Vous vous apprêtez à lire un tutoriel rédigé par un membre de ce site. Malgré tout le soin que ce membre a pu apporter au tutoriel, nous ne pouvons pas garantir que les informations contenues sur cette page sont exactes à 100%. Merci de garder cela en tête lorsque vous lirez cette page ;o)
On a appris ce qu'étaient les variables, les expressions, les opérateurs, mais pour l'instant, c'est pas encore un truc qui vous en met plein la vue.
Dans ce chapitre, on va tout mettre ensemble pour aborder des structures qui vont vous montrer ce que PHP a dans le ventre

.
Couplé avec les quelques chapitres suivants, vous pourrez faire plein de petites choses marrantes.
Grâce aux opérateurs de comparaison et aux opérateurs logiques, on peut faire des tests sur des expressions, sur des variables, sur des valeurs. Seulement, ça n'a pas grand intérêt si on ne peut pas utiliser ces résultats. Voilà -tout frais tout chaud- un bout de code comme on les aime :
Code : PHP 1
2
3
4
5
6
7
8
9
10 | <?php
$var = 5;
$test = $var <= 10;
if($test) {
var_dump('$var est plus petite ou égale à 10');
}
else {
var_dump('$var est plus grande que 10');
}
?>
|
Testez donc ce code, et que se passe-t-il ? Un seul
var_dump() affiche quelque chose. Changez la valeur de
$var (donnez-lui la valeur 15, par exemple) et observez : le second
var_dump() finira par être plus bavard. Mine de rien, on vient de voir une des structures de contrôle de PHP : la structure conditionnelle.
Mais comment ça marche ?
Vous voyez déjà deux nouveaux mots-clés,
if et
else. En français, ça veut dire
si et
sinon. En sachant ce que ça veut dire, vous devriez comprendre comment fonctionne ce code. On va d'ailleurs l'épurer pour ne conserver que la structure conditionnelle :
Code : PHP1
2
3
4
5
6
7
8 | <?php
if(Expression) {
// instruction si Expression est évaluée à true
}
else {
// instruction si Expression est évaluée à false
}
?>
|
Voilà donc la structure de base : j'ai utilisé le mot
Expression au lieu de la variable
$test, vous savez ce qu'est une expression, on l'a vu. On va donc affiner le fonctionnement de cette structure : si l'expression placée entre les parenthèses du
if est évaluée à
true, le bloc d'instructions du
if est exécuté, sinon c'est le bloc d'instruction du
else qui l'est.
Mais qu'est-ce qu'un bloc d'instructions ? Ce qu'on appelle ainsi, c'est ce qui est compris entre les accolades (
{}). Dans ces accolades, vous pouvez mettre diverses instructions. Par exemple, si vous faites un script pour afficher une news, vous allez d'abord vérifier que la news existe (avec l'expression adéquate entre les parenthèses qui suivent le
if). Si elle existe, vous mettrez diverses instructions qui afficheront la news, mais si elle n'existe pas, c'est le bloc d'instructions du
else qui sera exécuté, bloc d'instructions qui affichera une erreur par exemple. Les deux blocs ne seront jamais tous les deux exécutés : c'est soit l'un, soit l'autre, mais pas les deux.
Vous n'êtes pas obligés de créer des variables pour rien. Qu'est-ce que je veux dire ? Regardez mon premier code : je déclare deux variables,
$var et
$test. Mais je n'utilise pas
$test ailleurs que dans l'expression que je mets entre les parenthèses du
if, ma variable est donc inutile. Car
$var <= 10 est une expression, rappelez-vous !
On peut donc réécrire ce code comme tel :
Code : PHP1
2
3
4
5
6
7
8
9 | <?php
$var = 5;
if($var <= 10) {
var_dump('$var est plus petite ou égale à 10');
}
else {
var_dump('$var est plus grande que 10');
}
?>
|
Ce code produit exactement le même résultat, mais il est meilleur, car on n'utilise pas de variable inutile, et le script est donc plus performant, plus rapide. Amusez-vous à tester tout et n'importe quoi comme condition, mettez plusieurs instructions dans les différents blocs, bref, essayez un peu tout et n'importe quoi. Si vous savez ce qu'est une expression, que vous avez compris comment on utilise cette structure conditionnelle, tout ira sans problème.
Puisque c'est simple, encore un mot sur cette structure et sa petite soeur :
Code : PHP 1
2
3
4
5
6
7
8
9
10
11
12 | <?php
$var = 5;
if($var <= 10) { // si $var est plus petite ou égale à 10 on le dit
var_dump('$var est plus petite ou égale à 10');
}
elseif($var === 50) { // sinon si $var est égale à 50 on le dit aussi
var_dump('$var est égale à 50');
}
else { // sinon on dit que $var est plus grande ou égale à 10 et différente de 50
var_dump('$var est plus grande que 10 et différente de 50');
}
?>
|
Le mot-clé rajouté,
elseif, veut dire
sinon si. Ça vous permet de faire plus de tests. Prenons un exemple : imaginons que vous demandiez à un visiteur de choisir une couleur parmi trois. S'il a choisi la première, vous afficheriez qu'il aime le rouge, sinon s'il a choisi la seconde, vous lui afficheriez qu'il aime le bleu, sinon c'est qu'il a choisi la troisième, vous lui afficheriez qu'il aime le rose.
Il y a trois blocs d'instructions différents dans ce code, mais encore une fois, il n'y en a qu'un et un seul exécuté. Vous devez bien comprendre que dès qu'un des blocs est exécuté, les autres ne le seront pas. C'est pourquoi quand vous faites des conditions multiples, vous devez toujours mettre la condition la plus probable (celle qui a le plus de chances d'être vraie) dans le
if. Ainsi, PHP ne perdra pas de temps à évaluer les autres conditions.
Petite note sur le
else : il est facultatif. Vous n'avez pas besoin de spécifier un
else si vous n'en avez pas besoin. Imaginons que je veuille afficher quelque chose si
$var est égale à 70. Dans le cas contraire, je ne veux rien afficher. Au lieu de mettre un bloc d'instructions vide :
Code : PHP1
2
3
4
5
6
7
8 | <?php
$var = 70;
if($var == 70) {
var_dump('Oh yeah');
}
else {
}
?>
|
On peut oublier le
else :
Code : PHP1
2
3
4
5
6 | <?php
$var = 70;
if($var == 70) {
var_dump('Oh yeah');
}
?>
|
Les conditions (comme toutes les autres structures de contrôle, d'ailleurs) ont une place très importante en PHP. Je ne mentirais pas en vous disant que vous allez en bouffer jour après jour, alors tâchez de les maîtriser ! Et pour ça, pas de secret, il faut que vous jouiez avec

.
Dernier petit détail qui pourra vous servir : on peut interrompre le bloc de PHP dans les conditions. Je vous ai montré où placer votre code PHP, eh bien sachez que ce code fonctionne :
Code : PHP 1
2
3
4
5
6
7
8
9
10
11
12 | <?php
if(true) { //mettez false à la place et vous verrez
?>
<p>Bonjour !</p>
<?php
}
else {
?>
<p>Bonsoir !</p>
<?php
}
?>
|
Ici, vous voyez que j'ai directement mis le mot-clé
true entre les parenthèses du
if : on peut le faire, après tout,
true a une valeur, c'est donc une expression. Et comme il faut mettre une expression entre les parenthèses, on peut tout à fait le faire.
Depuis quelques lignes déjà, j'emploie souvent un mot : évaluer. Mais qu'est-ce que ça veut dire ?
Quand vous mettez une expression entre les parenthèses d'un
if ou d'un
elseif, cette expression est
évaluée (c'est-à-dire que l'expression est convertie, transtypée en sa valeur booléenne). Une expression évaluée ne peut prendre que deux valeurs, deux booléens bien connus :
true ou
false. Si l'expression est évaluée à
true, le bloc d'instructions est exécuté, sinon il ne l'est pas.
Dans le cas des opérateurs de comparaison et des opérateurs logiques, c'est simple étant donné que ces opérateurs ne renvoient que
true ou
false. Il n'y a donc aucune ambiguïté possible. Mais imaginons que je sois fou et que fasse ceci :
Code : PHP1
2
3
4
5
6
7
8 | <?php
if('lala') {
var_dump('La chaîne lala est évaluée à true');
}
else {
var_dump('La chaîne lala est évaluée à false');
}
?>
|
Je vois d'ici vos grands yeux ébahis : oui, cette chaîne de caractères est évaluée à
true. Surprenant, dites-vous ? Je vous réponds que c'est normal. PHP évalue certaines expressions à
true, d'autres à
false. La liste des expressions évaluées à
true est d'une longueur... infinie. Contrairement à la liste de ce qui est évalué à
false. C'est pourquoi je vais vous la donner.
- Le booléen false
- L'entier (INT) de valeur 0
- Le nombre à virgule (FLOAT) 0.0
- La chaîne de caractères vide et la chaîne de caractères '0'
- Le type spécial NULL.
La liste n'est pas complète, mais vous ne connaissez pas encore tous les types d'expressions possibles ; ça viendra par la suite.
Je suppose que maintenant vous savez quoi faire : testez. Amusez-vous à mettre des valeurs différentes de celles-là pour vérifier que c'est bien évalué à
true et testez ces valeurs pour vérifier qu'elles sont bien évaluées à
false.
Les structures précédentes,
if,
elseif et
else, conviennent parfaitement pour traiter des cas où il y a beaucoup de conditions différentes. Mais il y a une autre structure qui peut faire la même chose :
switch.
Personnellement, je ne l'utilise presque jamais. Beaucoup prétendent que le
switch améliore la lisibilité du code. Je vous le dis de suite : je ne vois aucune différence. Vous êtes donc totalement libres de choisir la structure qui vous plaira, mais moi je préfère le
if elseif 
. Il y a de rares cas où je l'utilise, mais je vous expliquerai ça plus tard, quand on parlera de performance.
Bref, passons aux codes :
Code : PHP 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 | <?php
$nb = 5;
if($nb == 0) {
var_dump('$nb vaut 0');
}
elseif($nb == 1) {
var_dump('$nb vaut 1');
}
elseif($nb == 2) {
var_dump('$nb vaut 2');
}
elseif($nb == 3) {
var_dump('$nb vaut 3');
}
elseif($nb == 4) {
var_dump('$nb vaut 4');
}
else {
var_dump('$nb vaut 5');
}
?>
|
Maintenant, voici exactement la même chose avec un
switch :
Code : PHP 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 | <?php
$nb = 5;
switch($nb) {
case 0 :
var_dump('$nb vaut 0');
break;
case 1 :
var_dump('$nb vaut 1');
break;
case 2 :
var_dump('$nb vaut 2');
break;
case 3 :
var_dump('$nb vaut 3');
break;
case 4 :
var_dump('$nb vaut 4');
break;
default :
var_dump('$nb vaut 5');
break;
}
?>
|
Le résultat est le même, seule la syntaxe diffère. Expliquons quand même cette syntaxe. On la réduit à sa plus simple expression :
Code : PHP 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 | <?php
switch(Expression) {
case Valeur :
// instruction 1
// instruction 2
//...
break;
case AutreValeur :
// instruction 1
// instruction 2
//...
break;
default :
// instruction 1
// instruction 2
//...
break;
}
?>
|
Entre les parenthèses du
switch, vous devez mettre l'expression dont vous voulez tester la valeur. PHP commence par évaluer cette expression. Ensuite, il va lire le
switch ligne par ligne. Lorsque PHP rencontre un
case Valeur :, deux comportements sont possibles.
- Soit la valeur de l'expression évaluée est égale à la valeur du
case,
- soit la valeur de l'expression évaluée n'est pas égale à la valeur du
case.
Dans le premier cas, PHP va exécuter les instructions qu'il rencontre jusqu'à ce qu'il trouve un
break;. Cette instruction est un peu particulière, je vais en parler brièvement maintenant mais on la reverra plus en détail par la suite.
break est une structure de contrôle qui permet de sortir, de briser la structure de contrôle qui l'encadre. Ici, la structure qui encadre le
break, c'est le
switch ; donc, dès que PHP rencontre un
break;, il sort du
switch et les instructions du
switch qui n'ont pas été exécutées ne le seront jamais.
Dans le second cas, PHP va continuer à lire le
switch jusqu'à rencontrer un
case.
Vous remarquez un dernier mot-clé,
default. C'est un
case un peu particulier, qui doit être placé en tout dernier. Si tous les
case ont échoué (c'est-à-dire que la valeur de l'expression évaluée n'est égale à aucune des valeurs des différents
case) et qu'il y un
default, alors les instructions de ce dernier bloc seront exécutées.
Le mieux pour bien comprendre, c'est encore et toujours de tester tout et n'importe quoi.
Sachez également qu'il est possible de ne pas mettre d'instruction dans un
case ; si ça arrive, PHP lira les instructions du
case suivant :
Code : PHP 1
2
3
4
5
6
7
8
9
10
11
12 | <?php
$i = 1;
switch($i) {
case 1 :
case 2 :
var_dump('$i est plus petit ou égal à deux');
break;
default :
var_dump('hu ?');
break;
}
?>
|
A côté des structures conditionnelles, un autre type de structure tient une grande place : les boucles. Concrètement, ça peut servir à beaucoup de choses : afficher un classement, une liste de nombres, etc.
Mieux qu'un discours :
Code : PHP1
2
3
4
5
6 | <?php
$lala = 0;
while(++$lala <= 10) {
var_dump($lala);
}
?>
|
Comme vous le voyez, je commence à mélanger tout : expressions, opérateurs en tous genres, variables, structures, etc. Donc s'il y a quoi que ce soit que vous n'avez pas bien compris, allez relire le chapitre qui en parle.
Je suppose que vous avez déjà testé ce code et que vous trouvez le résultat lamentable. Mettez un peu 1000 à la place de 10, et on verra si vous trouvez toujours ça lamentable

.
Voici la structure réduite à sa plus simple expression :
Code : PHP1
2
3
4
5 | <?php
while(Expression) {
// instructions
}
?>
|
Cette structure est extrêmement simple à comprendre : tant que
Expression est évaluée à
true, la boucle exécute le bloc d'instructions (les instructions comprises entre les accolades).
Concrètement, que se passe-t-il ?
PHP arrive sur le
while (qui, en français, veut dire "pendant que" ou "tant que") et évalue l'expression qui est entre parenthèses. Si l'expression est évaluée à
true, PHP exécute le bloc d'instructions puis réévalue l'expression. Si elle est toujours vraie, on recommence et ainsi de suite. Voilà d'ailleurs un risque : une boucle infinie. Imaginons que je mette simplement le booléen
true comme expression, ce sera toujours vrai, la boucle ne s'arrêtera jamais (mais PHP est gentil, il vous indiquera une erreur à force de tourner en rond

). Faites donc bien attention aux expressions que vous mettez entre les parenthèses. Vous devez être sûrs qu'elle sera évaluée au moins une fois à
false.
Mais en fait, c'est faux ; observons ce code :
Code : PHP1
2
3
4
5
6
7
8 | <?php
$i = 0;
while(++$i) { // condition toujours vraie, rappelez-vous de ce qui est évalué à false
if($i === 45) { // j'arrête ma boucle après 45 itérations
break;
}
}
?>
|
Vous vous souvenez de
break ? Cette instruction qui sert à sortir de l'instruction de contrôle qui l'encadre ? Eh bien grâce à lui, cette boucle qui paraissait infinie connaît une fin.
break ne peut servir à sortir que des structures de boucle ou d'un switch (pas d'un if, elseif ou else donc).
Dans le code, j'ai glissé un nouveau terme dans mes commentaires :
itération. Une itération, c'est une exécution de votre boucle. L'évaluation de l'expression et l'exécution du bloc d'instructions, c'est une itération. Ce terme reviendra souvent par la suite, mémorisez-le bien.
A l'instar des structures conditionnelles, il existe plusieurs structures de boucle, quatre en tout. On en a vu une, on va en découvrir une deuxième tout de suite. La troisième sera vue dans le chapitre suivant, la quatrième à un autre moment

.
Bref, voici sans plus attendre un code qui met en avant cette structure :
Code : PHP1
2
3
4
5
6 | <?php
$lala = 0;
do {
var_dump($lala);
} while(++$lala);
?>
|
Comme d'habitude, la structure réduite à sa plus simple expression :
Code : PHP1
2
3
4
5 | <?php
do {
// Instructions
} while(Expression);
?>
|
Si vous avez compris comment fonctionne
while, vous devriez comprendre celle-ci aussi. Tant que l'expression entre les parenthèses du
while est évaluée à
true, on refait un tour.
Mais alors pourquoi créer ces deux structures ? A première vue, elles paraissent très similaires, voire identiques. Mais un détail les différencie : le nombre d'itérations. La première structure de boucle qu'on a vue fera de 0 à n itérations. Cette dernière structure fera de 1 à n itérations.
Testons :
Code : PHP1
2
3
4
5
6
7
8 | <?php
while(false) {
var_dump('while');
}
do {
var_dump('do while');
} while(false);
?>
|
Si vous savez lire, vous constatez que "
while" ne s'affiche jamais. L'expression étant
false, la boucle ne fait pas une seule itération. Par contre, un "
do while" s'affiche. Eh oui : même si l'expression du
do while est évaluée à
false, le bloc d'instructions sera quand même exécuté une fois. D'où la différence entre les nombres d'itérations que j'ai mentionné ci-dessus.
En pratique, il est plutôt rare d'utiliser un
do while, mais ça peut arriver, je vous montrerai un cas dans lequel son utilisation nous rend un grand service

.
Si jamais vous avez une erreur de ce type :
Code : Console | Parse error: syntax error, unexpected $end in MesRepertoires\page.php on line 21 |
c'est probablement que vous avez oublié de fermer une accolade ; alors vérifiez qu'elles aillent toujours par paire !
Bientôt vous aurez droit à un TP, foncez lire le chapitre sur les fonctions.
Mais si vous avez du mal à appréhender quelque chose, prenez votre temps, comme toujours !