Introduction
Qu'est qu'une structure de contrôle ? Pour faire simple, une structure de contrôle est un ensemble d'instructions qui permet de contrôler l'exécution du code. Il en existe essentiellement deux types :
- Les structures de contrôle conditionnelles qui permettent d'exécuter certaines parties du code si une condition spécifique est remplie.
- Les structures de contrôle de boucle qui permettent d'exécuter en boucle certaines parties du code (généralement jusqu'à ce qu'une condition soit remplie).
Structures de contrôle conditionnelles
Instruction IF … ELSE …
IF (ConditionEstRemplie) { ExecuterCode1 } ELSE { ExecuterCode2 }
$boolean_IsValid = true;
if($boolean_IsValid)
{
// Code qui sera exécuté
}
else
{
// Code qui ne sera pas exécuté dans cet exemple
}
La commande ELSE peut être remplacée par la commande ELSEIF si une autre condition doit être vérifiée pour exécuter ExecuterCode2.
$boolean_IsValid1 = false;
$boolean_IsValid2 = true;
if($boolean_IsValid1)
{
// Code qui ne sera pas exécuté
}
elseif($boolean_IsValid2)
{
// Code qui sera exécuté
}
else
{
// Code qui ne sera pas exécuté
}
Instruction SWITCH
SWITCH (VariableAContrôler) { CASE Valeur1 : ExecuterCode1; CASE Valeur2 : ExecuterCode2; … ; DEFAULT : ExecuterCodeParDéfaut; }
Il est nécessaire d'insérer la commande BREAK pour n'exécuter que le code correspondant au CASE voulu. C'est-à-dire : supposons que VariablaAContrôler ai une valeur de Valeur1, alors ExecuterCode1 sera exécuté, si ExecuterCode1 se termine par la commande BREAK, l'exécution du code s'arrêtera là, sinon ExecuterCode2 sera exécuté, et ainsi de suite jusqu'à ce que la commande BREAK soit rencontrée ou que l’on arrive à la fin du SWITCH.
<?php
$ma_variable = 1;
switch ($ma_variable) {
case 1:
// Code si $ma_variable est égale à 1
echo $ma_variable.'<br />';
case 2:
// Code si $ma_variable est égale à 2 (ou 1 puisque le cas ci-dessus se poursuit en l'absent de "break")
echo $ma_variable.'<br />';
break;
case 3:
// Code si $ma_variable est égale à 3
echo $ma_variable.'<br />';
break;
default:
// Code dans tous les autres cas (equivaut à else)
echo $ma_variable.'<br />';
break;
}
?>
Ici, seul les instructions situées dans le "case 1" seront prisent en compte (le programme renvoie donc 1 1). À noter cependant que l'instruction switch() est (un peu) plus lente que l’utilisation du if, else et elseif. Cependant, elle s'avère très pratique dans les cas de redondance de conditions.
Opérateur ternaire
Condition ? ExecuterCode1 : ExecuterCode2;
Attention ! Ceci n’est pas a proprement parler une structure de contrôle (puisqu’il s'agit d’un opérateur). Il constitue néanmoins une alternative intéressante aux structures conditionnelles standard.
$boolean_IsValid = true;
($boolean_IsValid) ? /* Code qui sera exécuté */ : /* Code qui ne sera pas exécuté */ ;
Enfin, un dernier exemple permettant de faire le rapprochement entre les structures ternaires et les instructions if et else. Les codes ci-dessous renvois le même résultat :
Avec if et else :
$boolean_IsValid = true;
if ($boolean_IsValid) echo "La variable est vraie !";
else echo "La variable est fausse !";
Avec les ternaires :
$boolean_IsValid = true;
echo ($boolean_IsValid) ? "La variable est vraie !" : "La variable est fausse !";
Les deux codes affichent alors "La variable est vraie !". L'intérêt est donc de gagner du temps de codage et de la place :)
On peut aussi utiliser l'opérateur ternaire dans le but d’une affectation d’une variable :
$var = 5;
$foo = 21;
$min = ($var < $foo) ? $var : $foo;
/* $min vaut donc le minimum entre $var et $foo */
Structures de contrôle de boucle
Boucle FOR
FOR(ExpressionInitale ; ExpressionCondtionnelleDePoursuite ; ExpressionFinale) { ExecuterCodeBoucle }
ExpressionInitale s'exécute une seule fois avant de rentrer dans la boucle (sert généralement à initialiser les variables de la boucle).
ExpressionCondtionnelleDePoursuite sert de test d'exécution du corps de la boucle (de poursuite ou non de l'itération) : l’expression est évaluée avant chaque passage dans la boucle, si l’expression n’est pas vérifiée, le code n’est pas exécuté, et l’on sort de la boucle.
ExpressionFinale s'exécute a chaque fin de boucle. (sert généralement à incrémenter automatiquement les variables de la boucle)
for($i = 0 ; $i < 5 ; $i++)
{
// Code a exécuter a chaque passage de la boucle
}
Ici, le code a l'intérieur de la boucle sera exécuté 5 fois.
Boucle FOREACH
FOREACH ( TableauElements AS ElementCourant ) { ExecuterCodeBoucle }
ou bien : FOREACH ( TableauElements AS CleElement => ElementCourant ) { ExecuterCodeBoucle }
TableauElements constitue un tableau d'éléments à parcourir.
ElementCourant représente l'élément courant du tableau dans la boucle. Au début de chaque passage dans la boucle, un nouvel élément du tableau est automatiquement affecté a ElementCourant. La boucle s'arrêtera d'elle-même lorsque tous les éléments du tableau auront été parcourus.
CleElement représente la clé de l'élément courant dans un tableau associatif.
$Tableau_Couleur = array( 'Rouge', 'Vert', 'Jaune' );
foreach($Tableau_Couleur as $Nom_Couleur)
{// $Nom_Couleur sera égale à "Rouge" puis "Vert" puis "Jaune"
// Code à exécuter à chaque passage de la boucle
}
foreach($Tableau_Couleur as $Cle_Couleur => $Nom_Couleur)
{// Note : ici $Cle_Couleur sera une valeur numérique
// Code à exécuter à chaque passage de la boucle
}
$Tableau_Couleur = array( 'Couleur1' => 'Rouge', 'Couleur2' => 'Vert', 'Couleur3' => 'Jaune' );
foreach($Tableau_Couleur as $Cle_Couleur => $Nom_Couleur)
{// Note : ici $Cle_Couleur sera égale à Couleur1 puis Couleur2 puis Couleur3
// Code à exécuter à chaque passage de la boucle
}
Boucle WHILE
WHILE ( ExpressionConditionnelle ) { ExecuterCode }
$i = 1;
while($i <= 5)
{
$i++;
}
Ici, le compteur $i s'incrémentera jusqu'à avoir la valeur 5.
Boucle DO … WHILE
DO { ExecuterCode } WHILE ( ExpressionConditionnelle )
$i = 1;
do
{
$i++;
} while($i <= 5);
L'instruction do{ }while ressemble aux précédentes sauf que le code se trouvant à l'intérieur de la boucle sera exécuté au minimum une fois et ce, même si la condition de la boucle est déjà fausse (car la condition est placée après le bloc d'instructions). Cela peut être pratique dans certains cas.
Break et continue
Break
Il arrive souvent qu'on veuille sortir d’une boucle alors même que la condition de la boucle est encore vraie. Pour cela, on va faire appel à l'instruction break. Lorsque cette instruction sera exécutée, la boucle se terminera.
$i = 2;
while ($i <= 10)
{
if ($i == 5) break;
else $i++;
}
echo $i;
Ici, la boucle démarre avec $i = 2. La boucle du while va recommencer jusqu'à ce que la condition du if soit vérifiée. Celle-ci dit que lorsque $i est égal à 5, il faut sortir de la boucle. Par conséquent, le echo affichera bien 5 !
Continue
L'instruction continue ne permet pas de sortir d’une boucle mais simplement de finir un tour de boucle prématurément (avant la fin du bloc d'instruction). Cela sert moins souvent que break, mais cela peut servir à gérer des exceptions.
$mon_panier = array ('fruits' => 'orange', 'legume' => 'epinards', 'plat' => 'roti de veau');
$j_aime = 'epinards';
foreach ($mon_panier as $key => $value)
{
if ($value == $j_aime) continue;
echo $value.", ";
}
Ici, on parcourt les valeurs du tableau $mon_panier". Le if du bloc d'instruction est vérifié si la valeur ($value) est égale au contenu de la variable $j_aime (epinards). Lorsque la condition est vérifiée, le continue permet d'ignorer le reste de la boucle et de commencer un nouveau tour. Donc, le echo est ignoré et l’affichage d'"epinards" n’est pas pris en compte.
Le tout affichera "orange, roti de veau, ".