Les structures de contrôles

		

Nous allons maintenant étudier les différentes structures de contrôles .
 Les structures de contrôles nous permettrons de faire des tests entre les variables et d'exécuter 
 diverses boucles.
Voici un petit récapitulatif des principales structures de contrôles :
Instruction 		Signification
if 			Si
else 			Sinon
elseif 			Sinon si
switch 			Selon
for 			Pour chaque (boucle)
while			Tant que (boucle)
== 			Strictement égal
!= 			Différent
< 			Strictement inférieur
> 			Strictement supérieur
<= 			Inférieur ou égal
>= 			Supérieur ou égal
and ou &	 	ET logique
or ou ||		OU logique

Nous allons étudier ces structures de contrôles.

-	
if, else, elesif :

Nous allons déclarer une variable numérique $nombre avec une valeur 12 (par exemple), et faire différent
 tests dessus.
Exemple :

Code PHP :

<?php
$nombre = 12;
if ($nombre >= 0 and  $nombre < 10) {
// on teste si la valeur de notre variable est comprise entre 0 et 9
echo $nombre.' est compris entre 0 et 9';
}
elseif ($nombre >= 10 and $nombre < 20) {
// on teste si la valeur de notre variable est comprise entre 10 et 19
echo $nombre.' est compris entre 10 et 19';
}
else {
// si les deux tests précédents n'ont pas aboutis, alors on tombe dans ce cas
echo $nombre.' est plus grand que 19';
}
?>

A l'affichage on aura :
12 est compris entre 10 et 19

Les instructions qui doivent être exécutées lorsqu'un test est validé sont systématiquement mises entre 
des accolades { }.

Dans un premier temps, on teste si $nombre est supérieur ou égal à 0 et strictement inférieur à 10, et
 dans ce cas, on écrira alors sur l'écran, 
$nombre est compris entre 0 et 9.
Mais ce n’est pas le cas, $nombre est égal à 12, ce test ne sera pas satisfait.
On a alors deux solutions. Soit on écrit directement le cas Sinon (else), soit on peut faire un autres 
test, ce qui correspond à un SinonSi (elseif).
Nous avons choisis de faire un second test (elseif).
La, on teste si $nombre est supérieur ou égal à 10 et strictement inférieur à 20 (ce qui est notre cas 
car $nombre est égal à 12).
Le test est donc validé, et l'on exécute alors les instructions présentes entre les crochets { } du elseif.
On affichera donc à l'écran : 12 est compris entre 10 et 19
Viens ensuite le cas else qui est exécuté seulement si aucunes des conditions définies par les if et 
les elseif n'est vérifiées.

-
 switch :

Le switch est exactement comme si on exécute une  succession d'un if et de plusieurs elseif. Utiliser
un switch à un certain avantage comparé à un if et à plusieurs elesif, c'est que sa structure est 
beaucoup moins lourde et nettement plus agréable à lire.
Prenons un exemple simple. Nous allons déclarer une variable contenant une chaîne de caractères, puis 
nous allons tester cette chaîne grâce au switch.
On aura alors le code suivant :
Code PHP

<?php
$nom = "Carabde";
switch ($nom) {
case 'Jean' :
echo 'Votre nom est Jean.';
break;
case 'Dubois' :
echo 'Votre nom est Dubois.';
break;
case 'Carlos :
echo 'Votre nom est Carlos.';
break;
default :
echo 'Je ne connais pas votre nom!';
}
?>

Dans notre cas, vu que $nom contient la chaîne de caractère Carabde, on va alors afficher à l'écran la phrase
suivante :

Votre nom est Carabde.

En revanche, si la variable $nom avait contenu la chaîne de caractère "loulou", ce même code aurait 
affiché à l'écran :
Je ne connais pas votre nom!
En utilisant un if puis une succession de elseif, le code suivant aurait exactement eu le même affichage
 sur l'écran :
Code PHP :

<?php
$nom = "Carabde";
if ($nom == "Jean") {
echo 'Votre nom est Jean.';
}
elseif ($nom == "Dubois") {
echo 'Votre nom est Dubois.';
}
elseif ($nom == "Carlos") {
echo 'Votre nom est Carlos.';
}
else {
echo ' Je ne connais pas votre nom !';
}
?>

Attention !
Notez bien l'utilisation de break dans chaque cas de votre switch. Si celui-ci est oubliée, tous les
 messages s'afficheront.
Le break sert à casser la boucle dés que la condition est exécutée.

- 
for (pour chaque) :

La structure de contrôle for nous permet d'écrire des boucles. En clair, cela veut dire que nous allons
 exécuter une série d'instructions un nombre de fois bien déterminé.
Prenons l'exemple suivant :
Code PHP :

<?php
$chiffre = 10;
// Début de la boucle
for ($i=0; $i < $chiffre; $i++) {
echo 'Notre chiffre est différent de '.$i.'<br />';
}
// Fin de la boucle
echo 'Notre chiffre est égal à '.$i;
?>

Ce qui affichera à l'écran :
Notre chiffre est différent de 0
Notre chiffre est différent de 1
Notre chiffre est différent de 2
Notre chiffre est différent de 3
Notre chiffre est différent de 4
Notre chiffre est différent de 5
Notre chiffre est différent de 6
Notre chiffre est différent de 7
Notre chiffre est différent de 8
Notre chiffre est différent de 9
Notre chiffre est égal à 10

En effet, on initialise notre variable $chiffre à 10. On démarre la boucle for qui dit que l'on va 
exécuter les instructions situées entre les crochets de la boucle ({ }) pour i variant de 0 à $chiffre-1 
(donc jusqu'à 9), i étant incrémenter (augmenter) de 1 à chaque passage de boucle ($i++).
($i varie de 0 à $hiffre moins 1 car on impose que $i soit strictement inférieur à $chiffre).
On exécute alors 10 fois les instructions présentes dans la boucle, et à chaque passage, $i verra sa
 valeur augmentée de1.

L'utilisation des boucles est extrêmement importante (et indispensable) en programmation. La 
compréhension de ce passage est capital.

- 
while (tant que)

Voyons maintenant l'autre boucle, la boucle while ( tant que). Il faut déjà savoir que la boucle while
 est remplaçable par une boucle for.
Reprenons l'exemple précédent, et écrivons le à l'aide de la boucle while, on a :
Code PHP :

<?php
$chiffre = 10;
$i = 0;
// Début de la boucle
while ($i < $chiffre) {
echo 'Notre chiffre est différent de '.$i.'<br />';
$i = $i + 1;
}
// Fin de la boucle
echo 'Notre chiffre est égal à '.$i;
?>

Ce qui affichera à l'écran exactement la même chose que ce qu'affiche le code que l'on a utilise pour 
la boucle for.
Ici, on initialise notre variable $chiffre à 10, puis la variable $i à 0.
Ensuite, nous faisons le test suivant : "tant que $i est inférieur à $chiffre exécuter echo et augmenter 
la valeur de $i de 1"
Puis dès que la condition $i < $chiffre n'est plus vérifiée, nous sortons de la boucle pour finir 
l'exécution des instructions qui suivent.

Retourner au haut de la page..

...Précèdent...  		Vous êtes ici:les structures de controles		Voir la suite…