Les structures de contrôle : les boucles

• Par Emacs
• 13 commentaires
• 33223 lectures
• RSS -  Atom

Ce tutoriel fait suite à celui concernant les instructions conditionnelles. Les boucles constituent un principe trivial de l'informatique que tout développeur se doit de maîtriser. Elles font, elles aussi, partie des structures de contrôle. Le langage PHP en compte 4 ayant chacune ses spécificités : for(), while(), do-while() et foreach().

Qu'est-ce qu'une boucle ?

On appelle « boucle » une structure de contrôle capable d'exécuter un certain nombre de fois une même série d'instructions, en fonction d'une ou plusieurs conditions à vérifier.

Il faudra toujours vérifier que les conditions deviennent fausses (FALSE) à un moment donné afin de pouvoir sortir de la boucle. Dans le cas contraire, la boucle deviendra infinie et fera planter le programme tant que le max_execution_time du php.ini ne sera pas atteint.

La boucle for()

C'est la plus connue des boucles car elle est présente dans la majorité des langages de programmation. Paradoxalement, ce n'est pas forcément la plus utilisée en programmation PHP. Pourquoi ? Dans la plupart des langages de programmation, l'instruction for() sert à parcourir un tableau, alors que PHP dispose de sa propre instruction de contrôle foreach() spécialement dédiée pour cette tâche. Nous l'avions déjà évoquée dans le tutoriel sur les tableaux mais nous y reviendrons plus loin dans ce cours.

La particularité de la boucle for() (traduire « pour chaque itération ») est qu'il faut connaître par avance la condition d'arrêt. Autrement dit, la valeur qui rendra la condition fausse et stoppera la boucle. Sa syntaxe est simple et prend 3 paramètres obligatoires :

Syntaxe de la boucle for()
for(initialisation; condition; incrémentation)
{
  bloc d'instructions;
}

• L'initialisation est l'expression qui permet d'initialiser la boucle (valeur de départ). Généralement, les boucles débutent à la valeur 0.
• Le second paramètre correspond à la condition d'arrêt de la boucle. Cette condition est recalculée à chaque itération (passage de boucle) afin de déterminer si l'on continue de boucler ou bien si l'on sort de la boucle.
• Enfin, le dernier paramètre détermine l'expression qui sera exécutée à la fin d'une itération. Généralement on prévoit ici une incrémentation (ou décrémentation) pour mettre à jour le compteur de la boucle.

L'exemple qui suit montre la génération de la table de multiplication du chiffre 9.

Génération de la table de multiplication du chiffre 9 avec for()
<?php
  // Boucle générant la table de multiplication du 9
  for($i=0; $i<=10; $i++)
  {
    echo '9 x ', $i ,' = ', (9*$i) ,'<br/>';
  }
?>

Explications :

• Nous initialisons notre boucle à 0. Ce sera la première valeur qui sera multipliée au chiffre 9.
• Nous arrêtons la boucle lorsque le compteur $i atteindra la valeur 11. La valeur 10 passera mais quand $i vaudra 11 alors le programme sortira de la boucle.
• Nous déterminons l'action à exécuter à la fin de chaque itération. Ici on demande d'incrémenter automatiquement le compteur $i en écrivant $i++; (Rappel : $i++ <=> $i = $i+1).
• Nous affichons les 10 valeurs de la table de multiplication du 9. Le programme calcule chaque valeur en faisant le produit du 9 par le compteur $i.

Note : la variable $i est totalement arbitraire. Cette lettre est utilisée par convention (i pour indice) mais rien n'empêche d'écrire $compteur par exemple.

La boucle while()

La boucle while() (traduire par « tant que ») signifie que l'on va répéter un bloc d'instructions tant que la condition passée en paramètre reste vraie (TRUE). Lorsque celle-ci deviendra fausse (FALSE), le programme sortira de la boucle.

Sa syntaxe présentée ci-dessous :

Syntaxe de la structure conditionnelle while()
while(condition)
{
  bloc d'instructions;
}

On l'utilise particulièrement lorsque l'on extrait des informations d'une base de données. La particularité de cette instruction est que la condition n'est testée qu'après l'exécution complète du bloc d'instructions. Si la condition devient fausse avant la fin, le reste des instructions sera tout de même exécuté.

Reprenons notre exemple précédent mais cette fois-ci avec une boucle while().

Génération de la table de multiplication du chiffre 9 avec while()
<?php
  // Déclaration et initialisation du compteur
  $i = 0;
  // Boucle générant la table de multiplication du 9
  while($i<=10)
  {
    // Affichage de la nouvelle ligne
    echo '9 x ', $i ,' = ', (9*$i) ,'<br/>';
    // Incrémentation du compteur
    $i++;
  }
?>

Explications :

• Contrairement à la boucle for(), nous devons déclarer et initialiser notre compteur avant d'entrer dans la boucle. La valeur par défaut reste la même, à savoir 0.
• Puis nous déterminons la condition d'arrêt. Lorsque $i vaudra 11 alors nous sortirons de la boucle. La conditon $i<=$10 est toujours vraie tant que $i n'atteint pas la valeur 11.
• Enfin dans le corps de la boucle, nous calculons et affichons le produit de 9 par le compteur $i avant de finir par une incrémentation du compteur.

La boucle do { … } while()

L'instruction do {…} while() (traduire par « répéter / faire … tant que » est une alternative à l'instruction while() qui permet de tester la condition qu'après la première itération et exécution du premier bloc d'instructions. Voici sa syntaxe :

Syntaxe de la structures de contrôle do - while()
do 
{
  bloc d'instructions;
}
while(condition);

Avec notre exemple, cela donnerait :

Génération de la table de multiplication du chiffre 9 avec do - while()
<?php
  // Déclaration et initialisation du compteur
  $i = 0;
  // Boucle générant la table de multiplication du 9
  do
  {
    // Affichage de la nouvelle ligne
    echo '9 x ', $i ,' = ', (9*$i) ,'<br/>';
    // Incrémentation du compteur
    $i++;
  }
  while($i<=10);
?>

Explications :

• Nous commençons par initialiser le compteur à la valeur 0.
• Puis nous définissons la liste d'instruction à exécuter. C'est à dire, calcul, affichage du produit et incrémentation du compteur.
• Nous terminons par le test de la condition permettant de sortir ou non de la boucle.

Remarque : si nous avions initialisé le compteur $i à une valeur strictement supérieure à 10 (11, 12, 13...), alors le programme aurait calculé et affiché le produit de 9 par cette valeur puis serait sorti de la boucle car la condition est fausse dès le début.

La boucle foreach

Dans la plupart des langages de programmation, le parcours de tableau se réalise à l'aide de boucles. PHP dispose quant à lui de sa propre structure de contrôle permettant de parcourir le contenu d'un tableau. Il s'agit de la structure foreach(). C'est une boucle particulière qui avance le pointeur du tableau à chaque itération. Celle-ci a été intégrée depuis la version 4 de PHP et se présente sous deux syntaxes possibles :

Syntaxe de la structure de contrôle foreach()
<?php
  // Affichage des valeurs d'un tableau
  foreach($leTableau as $valeur) 
  {  
    echo $valeur ,'<br/>';
  }
 
  // Affichage des couples clé / valeur
  foreach($leTableau as $cle => $valeur) 
  {
    echo $cle ,' : ', $valeur ,'<br/>';
  }
?>

Cette structure prend en paramètre le nom du tableau à parcourir puis les données qu'il faut récupérer (valeurs uniquement ou bien valeurs + clés). Dans la première syntaxe, la valeur de l'élément courant du tableau est directement assignée à la variable $valeur. Dans la seconde, la clé courante de l'élément du tableau est affectée à la variable $cle et sa valeur stockée dans la variable $valeur.

Note : foreach() agit sur une copie du tableau d'origine.

Prenons deux tableaux d'exemple. L'un indexé numériquement et l'autre associativement. Nous allons les parcourir tous les deux au moyen de deux instructions foreach() de syntaxe différente.

Parcours de tableaux avec foreach()
<?php
  // Déclaration des deux tableaux
  $legumes = array('salade','oignon','piment','carotte','aubergine');
  $couleurs = array('rouge'=>'#ff0000', 'vert' => '#00ff00', 'bleu' => '#0000ff');
 
  // Affichage des légumes
  foreach($legumes as $legume) 
  {  
    echo $legume ,'<br/>';
  }
 
  // Affichage des couleurs et leur code hexadécimal
  foreach($couleurs as $couleur => $codeHexadecimal) 
  {
    echo $couleur ,' : ', $codeHexadecimal ,'<br/>';
  }
?>

Les instructions d'arrêt et de continuité

PHP introduit également deux instructions particulières des boucles. Il s'agit de continue et break. La première permet de forcer le passage à l'itération suivante en sautant tout ou partie du bloc d'instructions à exécuter. La seconde, quant à elle, permet de forcer à quitter une structure conditionnelle telle que for(), while(), foreach() ou switch().

Ces deux instructions peuvent prendre un paramètre optionnel de type entier permettant de connaître le nombre de structures emboîtées qui ont été interrompues.

Illustrons brièvement ces deux concepts à l'aide d'exemples simples.

Exemple d'utilisation de continue
<?php
  for($i=0; $i<=10; $i++) 
  {
    // On n'affiche pas les 5 premiers nombres
    if($i<=5)
    {
      continue;
    }
    // Affichage des nombres de 6 à 10
    echo $i ,'<br/>';
  }
?>

Dans cet exemple, nous souhaitons commencer à itérer depuis la valeur 0 mais nous ne voulons afficher que les valeurs comprises de 6 à 10. Grâce à la condition et au mot-clé continue, nous parvenons à ne pas afficher les 6 premières valeurs.

Remarque : nous aurions pu obtenir le même résultat sans utiliser le mot-clé continue en remplaçant la condition du if() par $i > 5 et en plaçant l'instruction echo() à la place du continue.

Exemple d'utilisation de break
<?php
  for($i=0; $i<=10; $i++) 
  {
    // On affiche la valeur du compteur
    echo 'Compteur = ';
    // On sort de la boucle si on atteint le chiffre 5
    if($i>5)
    {
      break;
    }
    // Affichage des nombres de 0 à 5
    echo $i ,'<br/>';
  }
?>

Cet exemple illustre l'emploi du mot-clé break. Ici nous demandons de sortir de la boucle dès que l'on atteint le chiffre 5. Pour nous convaincre du résultat, voici le résultat généré :

Résultat de l'exécution du script
Compteur = 0  
Compteur = 1  
Compteur = 2  
Compteur = 3  
Compteur = 4  
Compteur = 5  
Compteur =

Nous remarquons ici que nous sommes entrés dans la 7^ème itération. Le programme exécute la première instruction puis passe le test. La condition est vraie donc l'instruction break est exécutée, ce qui force la sortie de la boucle.

Conclusion

Cette seconde partie du cours au sujet des structures de contrôle a été l'occasion de découvrir le concept de boucle. Nous avons donc étudié les structures itératives for(), while(), do-while() et foreach() avant de terminer par les deux instructions particulières continue et break.