Aller au menu - Aller au contenu

[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)
Avatar
Auteur : `Haku
Visualisations : 2 756

Plus d'informations Plus d'informations
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.
Sommaire du chapitre :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant

Structures conditionnelles

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 : PHP
1
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 : PHP
1
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 : PHP
1
2
3
4
5
6
7
8
<?php
$var = 70;
if($var == 70) {
    var_dump('Oh yeah');
}
else {
}
?>

On peut oublier le else :
Code : PHP
1
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.

Évaluation

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 : PHP
1
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.
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.

Autre structure conditionnelle

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;
}
?>

Structure de boucle : partie I

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 : PHP
1
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 :p .

Voici la structure réduite à sa plus simple expression :
Code : PHP
1
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 : PHP
1
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.

Structure de boucle : partie II

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 : PHP
1
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 : PHP
1
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 : PHP
1
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 :) .

Q.C.M.

Qu'affiche ce code ?
Code : PHP
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
<?php
if('meuhlavache') {
    $i = 0;
    while(++$i < 5) {
        if($i === 5) {
            var_dump('vive le chocolat');
        }
        elseif($i % 8 > $i) {
            var_dump('vive le rose');
        }
    }
}
?>
Qu'affiche ce code ?
Code : PHP
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
<?php
$i = 0;
switch($i) {
    case 2 :
    case 1 :
        break;
    case 0 :
    case -1 :
        do {
            var_dump($i);
        } while($i);
    case 4 :
        var_dump($i);
        break;
    default : 
        break;
}
?>

Statistiques de réponses au QCM


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 !
Chapitre précédent Sommaire Chapitre suivant
Retour en haut Retour en haut


Créé : le 20/07/2007 à 10:52:43
Modifié : le 22/08/2008 à 15:54:57
Avancement : 0%
Licence : Copie non autorisée

Changer de design | En savoir plus | Plan du site | Politique d'accessibilité | Règles | RSS tutoriels | RSS news | XHTML 1.0 | CSS 2.0
Édité par Simple IT SARL : Nous contacter | Revue de presse | Publicité

Y'a plus rien à lire, faut remonter maintenant !

Hébergement web - Correction de tutoriels - Créer un site
Vous souhaitez apparaître ici ? Contactez-nous.

Nombre de connectés 152 Zéros connectés | Requêtes SQL 8 requêtes | Temps de génération de la page : Total (SQL) 0.0388s (0.0154s)