Programmation Perl/Tests

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche
Programmation Perl
Programmation Perl
Sommaire




Modifier ce modèle


Les tests[modifier | modifier le wikicode]

Il existe plusieurs manières d'effectuer un test, qui est couramment appelé « évaluer une expression » en jargon informatique. Nous allons voir les méthodes les plus courantes.

Les mots clés[modifier | modifier le wikicode]

  • if, elsif, else, unless

Le mot clé utilisé pour faire des tests est if (ou unless si on veut tester négativement). Si le test échoue, nous pouvons mettre la condition "sinon si" : elsif. Nous pouvons enchaîner autant de elsif que nous le souhaitons. Un bloc de code est exécuté si tous les autres tests précédents ont échoué via le mot clé else. Unless peut être vu comme l'inverse de if (si n'est pas).

Syntaxe[modifier | modifier le wikicode]

Syntaxe classique if elsif else[modifier | modifier le wikicode]

Nous allons voir comment effectuer des tests et exécuter différentes parties du code en fonction des valeurs de nos variables. Cette syntaxe est particulièrement connue car utilisée dans de nombreux langages.

 1 if ( expression )
 2 {
 3         instructions
 4 }
 5 elsif ( expression )
 6 {
 7         instructions
 8 }
 9 else
10 {
11         instructions
12 }

Attention : il ne faut pas mettre de point virgule (;) à la fin de toutes les lignes, relisez bien le code pour savoir où les placer ! Contrairement à certains langages, nous ne pouvons pas ommettre les accolades ({}) dans cette version du test.

exemple[modifier | modifier le wikicode]
 1 my $a = 5;
 2 my $b = 8;
 3 if ( $a > $b )
 4 {
 5         say "$a est plus grand que $b";
 6 }
 7 elsif ( $a < $b )
 8 {
 9         say "$a est plus petit que $b";
10 }
11 else
12 {
13         say "$a et $b sont égaux";
14 }

condition après instruction conditionnée[modifier | modifier le wikicode]

1 instruction if ( expression ) ;

Ce code est bien plus court, et avec cette syntaxe nous n'avons pas besoin de mettre les parenthèses.

exemple[modifier | modifier le wikicode]
1 my $a = 6;
2 my $b = 5;
3 say $a if $a > $b;

Ce code affiche "6" car $a > $b. Cependant, cette façon d'écrire le test d'une série d'expressions ne permet pas l'utilisation de elsif, de else, et ne permet l'exécution conditionnelle que d'une seule instruction.

Cette méthode permet de lire l'instruction conditionnée comme si on lisait une phrase => "fais ceci SI cela".

Syntaxe condition ternaire[modifier | modifier le wikicode]

1 expression ? instruction_si_vrai : instruction_si_faux ;
exemple[modifier | modifier le wikicode]
1 my $a = 6;
2 my $b = 5;
3 $a > $b ? say "$a plus grand que $b" : say "$a plus petit que $b" ;

$a ( valeur = 6) est plus grand que $b (valeur = 5) donc on affiche "$a plus grand que $b".

Opérateurs de tests[modifier | modifier le wikicode]

Il y a un certain nombre d'opérateurs qui permettent de faire des tests sur des nombres (scalaires numériques), des chaînes (toujours des scalaires) ou des listes.

Opérateurs de tests numériques[modifier | modifier le wikicode]

Tout d'abord, les tests de comparaisons classiques comme dans les autres langages (et en mathématiques) :

  • < , > , <= , >= , == , !=

Ils nous permettent de faire des tests très simples "si $a plus grand que $b". Un peu moins répandu :

  • <=>

Opérateurs de tests sur chaînes[modifier | modifier le wikicode]

Ces opérateurs travaillent sur des chaînes de caractères. Une chaîne "plus petite" qu'une autre est une chaîne qui apparaît avant dans l'ordre lexicographique.

  • lt (plus petit que) , gt (plus grand que),
  • le (plus petit ou égal) , ge (plus grand ou égal) ,
  • eq (égal) , ne (non égal).
exemple[modifier | modifier le wikicode]
 1 my $chaine1 = "coucou";
 2 my $chaine2 = "zzz";
 3 if( $chaine1 lt $chaine2 ) # rappel : lt = plus petit que dans ordre lexicographique
 4 {
 5         say $chaine1;
 6 }
 7 elsif( $chaine2 lt $chaine1 ) # si $chaine2 arrive plus tôt dans l'ordre lexicographique que $chaine1
 8 {
 9         say $chaine2;
10 } 
11 else
12 {
13         say "Les chaînes sont égales !";
14 }

Opérateurs pour tester plusieurs expressions[modifier | modifier le wikicode]

Commençons par les mots clés :

  • or, and, : « ou » et « et »
  • ||, && : « ou » et « et »

Nous verrons plus tard la notion de précédence.

Ce qu'il faut savoir pour évaluer plusieurs expressions est que l'on peut combiner des expressions pour en former une seule grande. Comme nous l'avons vu, une expression est souvent un test entre parenthèses :

( $a >= $b )

Nous pouvons créer une expression plus grande, combinant celle-ci avec d'autres :

 (($a >= $b) || ($a == 5))

Ici, nous évaluons la première expression ($a >= $b) et avec le « ou » (les deux barres verticales ||) nous évaluons la seconde expression seulement si la première a échouée ($a est un nombre inférieur à $b). Si à la place du « ou » (||) nous avions un « et » (&&), il faudrait que les deux expressions qui l'entourent soient testées positivement pour que l'expression globale soit vraie.

exemple[modifier | modifier le wikicode]
1 my $a = 5 ;
2 my $b = 10 ;
3 say "$a" if( ($a < $b && ($a * 2) > $b) || $a == 5);

On affiche $a si ($a est inférieur à $b et que son double ($a * 2) est supérieur à $b) ou si $a est égal à 5. $a ne correspond pas au premier test entre parenthèses ($a < $b && ($a * 2) > $b) car une des deux conditions nécessaires n'est pas remplie. Donc le premier test est négatif et on va exécuter la seconde série de tests après le « ou » (||), $a est égal à 5, donc la série globale est validée. On affiche 5 (la valeur de la variable $a).