Programmation Perl/Tests

Les tests

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

• 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

Syntaxe classique if elsif else

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.

if ( expression )
{
        instructions
}
elsif ( expression )
{
        instructions
}
else
{
        instructions
}

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

my $a = 5;
my $b = 8;
if ( $a > $b )
{
        say "$a est plus grand que $b";
}
elsif ( $a < $b )
{
        say "$a est plus petit que $b";
}
else
{
        say "$a et $b sont égaux";
}

condition après instruction conditionnée

instruction if ( expression ) ;

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

exemple

my $a = 6;
my $b = 5;
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

expression ? instruction_si_vrai : instruction_si_faux ;

exemple

my $a = 6;
my $b = 5;
$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

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

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 :

• <=>

#!/usr/bin/perl -w
use strict;

# opérateur <=>, ses 3 réponses possibles

my ($a,$b)= (5,6);
print ($a<=>$b);# -1
print "\n";

print ($b<=>$a);# 1
print "\n";

($a,$b)= (5,5);
print ($a<=>$b);# 0
print "\n";

Opérateurs de tests sur chaînes

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

my $chaine1 = "coucou";
my $chaine2 = "zzz";
if( $chaine1 lt $chaine2 ) # rappel : lt = plus petit que dans ordre lexicographique
{
        say $chaine1;
}
elsif( $chaine2 lt $chaine1 ) # si $chaine2 arrive plus tôt dans l'ordre lexicographique que $chaine1
{
        say $chaine2;
} 
else
{
        say "Les chaînes sont égales !";
}

valeurs booléennes retournées: 1 ou vide

#!/usr/bin/perl -w
use strict;

my ($a,$b)= (5,6);
print ($a lt $b);# 1
print "\n";

print">>>";
print ($a gt $b);# >>><<< chaine vide mais définie !
print "<<<\n";
print defined ($a gt $b);# 1

Opérateurs pour tester plusieurs expressions

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

my $a = 5 ;
my $b = 10 ;
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).