On appelle structure conditonnelle les instructions qui permettent de tester si une condition est vraie ou non. Ces structures conditionnelles peuvent être associées à des structures qui se répètent suivant la réalisation de la condition, on appelle ces structures des structures de boucle
La notion de bloc
Une expression suivie d'un point-virgule est appelée instruction. Par exemple $a++; est une instruction.
Lorsque l'on veut regrouper plusieurs instructions, on peut créer ce que l'on appelle un bloc, c'est-à-dire un ensemble d'instructions (suivies respectivement par des point-virgules) et comprises entre les accolades { et }.
Les instructions if, while et for peuvent par exemple être suivies d'un bloc d'instructions à exécuter...
L'instruction if
L'instruction if est la structure de test la plus basique, on la retrouve dans tous les langages (avec une syntaxe différente...). Elle permet d'exécuter une série d'instructions si jamais une condition est réalisée.
La syntaxe de cette expression est la suivante:
- Code: Tout sélectionner
if (condition réalisée) {
liste d'instructions;
}
else {
liste d'instructions;
}
Remarques:
la condition doit être entre des parenthèses
il est possible de définir plusieurs conditions à remplir avec les opérateurs ET et OU (&& et ||)
par exemple l'instruciton suivante teste si les deux conditions sont vraies
if ((condition1)&&(condition2))
L'instruction ci-dessous exécutera les instructions si l'une ou l'autre des deux conditions est vraie
if ((condition1)||(condition2))
les instructions situées dans le bloc qui suit else sont les instructions qui seront exécutées si la ou les conditions ne sont pas remplies
Contrairement au langage C, les parenthèses de bloc ne peuvent pas être omises lorsqu'il n'y a qu'une seule instruction!
L'instruction if ... else
L'instruction if dans sa forme basique ne permet de tester qu'une condition, or la plupart du temps on aimerait pouvoir choisir les instructions à exécuter en cas de non réalisation de la condition...
L'expression if ... else permet d'exécuter une autre série d'instructions en cas de non-réalisation de la condition.
La syntaxe de cette expression est la suivante:
- Code: Tout sélectionner
if (condition réalisée) {
liste d'instructions;
}
else {
autre série d'instructions;
}
une façon plus courte de faire un test (opérateur ternaire)
Il est possible de faire un test avec une structure beaucoup moins lourde grâce à la structure suivante, appelée opérateur ternaire:
(condition) ? instruction si vrai : instruction si faux
Remarques:
la condition doit être entre des parenthèses
Lorsque la condition est vraie, l'instruction de gauche est exécutée
Lorsque la condition est fausse, l'instruction de droite est exécutée
L'instruction if ... elsif ... else
L'instruction if ... else ne permet de tester qu'une condition, or il est parfois nécessaire de tester plusieurs conditions de façon exclusive, c'est-à-dire que sur toutes les conditions une seule sera réalisée ...
L'expression if ... elsif ... else permet d'enchaîner une série d'instructions et évite d'avoir à imbriquer des instructions if.
La syntaxe de cette expression est la suivante:
- Code: Tout sélectionner
if (condition réalisée) {
liste d'instructions;
}
elsif (autre condition réalisée) {
autre série d'instructions;
}
...
else (dernière condition réalisée) {
série d'instructions;
}
Perl ne contient pas d'instruction switch
L'instruction unless
Perl propose l'instruction unless, qui permet d'exécuter une instruction seulement si la condition associée est fausse.
La syntaxe de cette expression est la suivante:
- Code: Tout sélectionner
unless (condition non réalisée) {
liste d'instructions
}
Les boucles
Les boucles sont des structures qui permettent d'exécuter plusieurs fois la même série d'instructions jusqu'à ce qu'une condition ne soit plus réalisée...
On appelle parfois ces structures instructions répétitives ou bien itérations.
La façon la plus commune de faire une boucle, est de créer un compteur (une variable qui s'incrémente, c'est-à-dire qui augmente de 1 à chaque tour de boucle) et de faire arrêter la boucle lorsque le compteur dépasse une certaine valeur.
La boucle for
L'instruction for permet d'exécuter plusieurs fois la même série d'instructions: c'est une boucle!
Dans sa syntaxe, il suffit de préciser le nom de la variable qui sert de compteur (et éventuellement sa valeur de départ, la condition sur la variable pour laquelle la boucle s'arrête (basiquement une condition qui teste si la valeur du compteur dépasse une limite) et enfin une instruction qui incrémente (ou décrémente) le compteur.
La syntaxe de cette expression est la suivante:
- Code: Tout sélectionner
for (compteur; condition; modification du compteur) {
liste d'instructions
}
Par exemple:
- Code: Tout sélectionner
for ($i=1; $i<6; $i++) {
printf("%d", $i);
}
Cette boucle affiche 5 fois la valeur de i, c'est-à-dire 1,2,3,4,5
Elle commence à $i=1, vérifie que i est bien inférieur à 6, etc... jusqu'à atteindre la valeur i=6, pour laquelle la condition ne sera plus réalisée, la boucle s'interrompra et le programme continuera son cours.
D'autre part, le langage Perl autorise la déclaration de la variable de boucle dans l'instruction for elle-même!
Par exemple:
- Code: Tout sélectionner
for ($i=0; $i<10; $i++) {
printf("%d", $i);
}
il faudra toujours vérifier que la boucle a bien une condition de sortie (i.e le compteur s'incrémente correctement)
une instruction printf(); dans votre boucle est un bon moyen pour vérifier la valeur du compteur pas à pas en l'affichant!
il faut bien compter le nombre de fois que l'on veut faire exécuter la boucle:
for(i=0;i<10;i++) exécute 10 fois la boucle (i de 0 à 9)
for($i=0;$i<=10;$i++) exécute 11 fois la boucle ($i de 0 à 10)
for($i=1;$i<10;$i++) exécute 9 fois la boucle ($i de 1 à 9)
for($i=1;$i<=10;$i++) exécute 10 fois la boucle ($i de 1 à 10)
L'instruction while
L'instruction while représente un autre moyen d'exécuter plusieurs fois la même série d'instructions.
La syntaxe de cette expression est la suivante:
- Code: Tout sélectionner
while (condition réalisée) {
liste d'instructions
}
Cette instruction exécute la liste d'instructions tant que (while est un mot anglais qui signifie tant que) la condition est réalisée. La condition de sortie pouvant être n'importe quelle structure conditionnelle, les risques de boucle infinie (boucle dont la condition est toujours vraie) sont grands, c'est-à-dire qu'elle risque de provoquer un plantage du navigateur!
L'instruction until
L'instruction until est similaire à l'instruction while, à la différence près que le test est inversé.
La syntaxe de cette expression est la suivante:
- Code: Tout sélectionner
until (condition non réalisée) {
liste d'instructions
}
L'instruction foreach
L'instruction foreach permet d'effectuer une boucle qui parcourt une liste. A chaque tour de boucle, l'élément de la liste est affecté à la variable $VAR. LISTE peut par exemple être un tableau, dont l'instruction foreach va parcourir les enregistrements.
La syntaxe de cette expression est la suivante:
- Code: Tout sélectionner
foreach $VAR (LISTE) {
liste d'instructions;
}
Saut inconditionnel
Il peut être nécessaire de faire sauter à la boucle une ou plusieurs valeurs sans pour autant mettre fin à celle-ci.
La syntaxe de cette expression est "next;" (cette instruction se place dans une boucle!), on l'associe généralement à une structure conditionnelle, sinon les lignes situées entre cette instruction et la fin de la boucle seraient obsolètes. Elle est très proche de l'instruction continue du langage C.
Exemple: Imaginons que l'on veuille imprimer pour $x allant de 1 à 10 la valeur de 1/($x-7) ... il est évident que pour $x=7 il y aura une erreur. Heureusement, grâce à l'instruction nexte il est possible de traiter cette valeur à part puis de continuer la boucle!
- Code: Tout sélectionner
#!/usr/local/bin/perl
$x=1;
while ($x<=10) {
if ($x == 7) {
printf("Division par zéro!\n");
next;
}
$a = 1/($x-7);
printf("%d", $a);
$x++;
}
Il y avait une erreur dans ce programme... peut-être ne l'avez-vous pas vue:
Lorsque $x est égal à 7, le compteur ne s'incrémente plus, il reste constamment à la valeur 7, il aurait fallu écrire:
- Code: Tout sélectionner
#!/usr/local/bin/perl
$x=1;
while ($x<=10) {
if ($x == 7) {
printf("division par 0");
$x++;
next;
}
$a = 1/($x-7);
printf("%d", $a);
$x++;
}
Arrêt inconditionnel
A l'inverse, il peut être voulu d'arrêter prématurément la boucle, pour une autre conditon que celle précisé dans l'en-tète de la boucle. L'instruction last permet d'arrêter une boucle (for ou bien while). Il s'agit, tout comme newt, de l'associer à une structure conditionnelle, sans laquelle la boucle ne ferait jamais plus d'un tour!
Dans l'exemple de tout à l'heure, par exemple si l'on ne savait pas à quel moment le dénominateur ($x-7) s'annule (bon...OK...pour des équations plus compliquées par exemple) il serait possible de faire arrêter la boucle en cas d'annulation du dénominateur, pour éviter une division par zéro!
- Code: Tout sélectionner
for ($x=1; $x<=10; $x++) {
a = $x-7;
if ($a == 0) {
printf("division par 0");
last;
}
printf("%d", 1/$a);
}
