FAQ PerlConsultez toutes les FAQ

En Perl, il est possible et même souhaitable d'organiser le code en blocs d'instructions. Ces blocs seront exécutés ou non en fonction de différentes conditions (que l'on nomme alternatives) ou pourront être répétés autant que de besoin (itératives).
Un bloc débute par une accolade ouvrante et se termine par une accolade fermante.
Les blocs peuvent être imbriqués les uns dans les autres. Un bloc peut contenir indifféremment d'autres blocs ou des commandes isolées. Il est de coutume d'indenter les blocs, c'est-à-dire d'introduire un ou plusieurs espaces de marge à gauche des instructions contenues dans les blocs. Plus il y a des niveaux d'imbrication, plus on introduit des espaces. Ceci permet une lecture plus aisée de la structure du code et permet même à certains éditeurs de texte de la mettre en valeur par des barres verticales reliant le début à la fin du bloc, ou par l'apparition de boutons permettant de masquer/démasquer le bloc à volonté (cas de Scintilla Text Editor, logiciel libre d'édition de code source).

La notion de bloc d'instructions limite la visibilité des variables. En effet, quel que soit leur type (scalaire, tableau, table associative), les variables ne sont visibles - accessibles - qu'à l'intérieur du bloc où elles sont définies. Elles sont donc utilisables à l'intérieur de la paire d'accolades contenant leur déclaration ou à l'intérieur des blocs que celle-ci contient. En outre, toute redéclaration d'une variable de même nom à l'intérieur d'un bloc masquera automatiquement la valeur que la variable avait acquise à l'extérieur de ce bloc. La variable reprendra sa valeur d'origine aussitôt que l'exécution du bloc contenant la redéclaration sera terminée. On parle alors de variables locales, la portée de la variable (là où l'on peut l'utiliser) étant limitée à ce seul bloc d'instructions.

La portée et la visibilité que l'on vient de définir sont en fait valables pour les variables déclarées au moyen du mot-clef my. Celui-ci limite la portée de la variable au bloc en cours d'exécution. Pour qu'une variable soit accessible hors de ce bloc, il existe deux solutions :

• définir cette variable hors de tout bloc d'instructions. Elle est alors disponible dans tout le script ;
• déclarer cette variable avec le mot-clef our. Elle est alors disponible dans tout le script et peut même - sous certaines conditions (cas des modules) - être accédée depuis l'extérieur.
  

Il y a souvent besoin de réaliser un choix entre deux blocs à traiter selon la valeur d'une condition. C'est ce que l'on appelle une alternative.

En Perl, une condition est une expression, constituée de variables, de valeurs, d'opérateurs de test (<,>, ne, !=, le, ge, cmp...) et éventuellement d'opérateurs de combinaison logique (not, and, or, xor). Le tout doit être habilement mis entre parenthèses afin de garantir les associations de tests souhaitées.

Perl met à notre disposition deux types d'alternative :

• l'instruction if, qui représente l'alternative favorable - quand une condition est remplie ;
• l'instruction unless, qui représente l'alternative défavorable - quand une condition n'est pas remplie.
  

1
2
3
if ( condition ) { 
  # bloc d'instructions à exécuter si la condition est vraie 
}

1
2
3
4
5
if ( condition ) { 
  # bloc d'instructions à exécuter si la condition est vraie 
} else { 
  # bloc d'instructions à exécuter si la condition est fausse 
}

1
2
3
4
5
6
7
8
9
10
11
if ( condition_primaire ) { 
  # bloc d'instructions à exécuter si la condition primaire est vraie 
}  
elsif (nouvelle_condition) { 
  # bloc d'instructions à exécuter si la nouvelle condition est vraie 
  #                                alors que la condition primaire est fausse 
}  
else { 
  # bloc d'instructions à exécuter si la nouvelle condition est fausse 
  #                                alors que la condition primaire est fausse 
}

1
2
3
unless ( condition ) { ... } 
# et  
if ( ! ( condition ) ) { ... }

Il est possible en Perl d'utiliser les conditions ternaires si vous souhaitez faire des if/elsif/elsif/else. Son utilisation est pratique du fait qu'on ait moins de lignes de code à écrire, que la visibilité du code peut être meilleure et cela nous oblige à faire un else sous peine de recevoir un message d'erreur.

L'écriture est de la sorte : Condition ? exécution si vrai : exécution si faux;

Rien de mieux qu'un exemple.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#!/usr/bin/perl 
use strict; 
use warnings; 
  
my $nombre = 20; 
my $limite = 20; 
my $reponse; 
  
# if/elsif/else 
if ( $nombre < $limite ) { 
  $reponse = "$nombre plus petit que $limite"; 
} 
elsif  ( $nombre > $limite ) { 
  $reponse = "$nombre plus grand que $limite"; 
} 
else { 
  $reponse = "$nombre est identique à $limite"; 
} 
print "if/else/else : $reponse\n";

1
2
3
4
5
6
7
8
9
10
11
12
13
#!/usr/bin/perl 
use strict; 
use warnings; 
  
my $nombre = 20; 
my $limite = 20; 
my $reponse; 
  
               # condition            # reponse 
my $reponse2 = $nombre < $limite ? "$nombre plus petit que $limite" 
            :  $nombre > $limite ? "$nombre plus grand que $limite" 
            :                         "$nombre est identique à $limite"; 
print "condition ternaire : $reponse2\n";

my $reponse2 = $nombre < $limite ? "$nombre plus petit que $limite";

Les alternatives que nous venons de voir sont très utiles mais nécessitent l'ouverture et la fermeture de blocs de codes. Cela peut être fastidieux, juste pour une instruction dont l'exécution est conditionnelle. Perl a donc introduit une expression simplifiée pour l'exécution conditionnelle d'une seule instruction :

instruction if (condition);

instruction unless (condition);

1
2
3
4
5
6
7
8
foreach my $case ( @tableau ) { 
	next if ( condition1 ); 
  
	if ( condition2 ) { 
		# action 1 
		# action 2 
	}  
}

Lorsque l'on a une même variable à tester dans différentes conditions, pour vérifier les différentes valeurs possibles, il est nécessaire d'utiliser une batterie de if/elsif/else, ce qui peut paraître rapidement fastidieux et peu clair :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
if ( $choix == 0 ) { 
  
  # traitement du 0 
} 
elsif ( $choix == 1 ) { 
  
  # traitement du 1 
} 
elsif ( $choix == 2 ) { 
  
  # traitement du 2 
} 
elsif ( $choix == 3 ) { 
  
  # traitement du 3 
} 
else { 
  
  # traitement par défaut 
}

• Utilisateurs d'une version de Perl inférieure ou égale à la 5.8
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
use Switch 'Perl6'; 
  
# pour avoir le mécanisme de la sélection conforme à ce que permettra Perl6 
given ($choix) { 
  when 0 { 
  
    # traitement du 0 
  } 
  when 1 { 
  
    # traitement du 1 
  } 
  when 2 { 
  
    # traitement du 2 
  } 
  when 3 { 
  
    # traitement du 3 
  } 
  when /.*/ { 
  
    # traitement par défaut 
  } 
}

• Utilisateurs d'une version de Perl supérieure ou égale à la 5.10
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
use feature qw/switch/; 
  
given ($string) { 
  when (/^abc/) { $abc     = 1; } 
  when (/^def/) { $def     = 1; } 
  when (/^xyz/) { $xyz     = 1; } 
  default       { $nothing = 1; } 
} 
  
# Code issu de la documentation de Sébastien Aperghis-Tramoni 
given ($number) { 
  when (42) { say "La Réponse"; } 
  when (56) { say "fer standard"; } 
} 
  
use Regexp::Common qw/net/; 
  
given ($host) { 
  when ("localhost")        { say "adresse locale"; } 
  when (/$RE{net}{IPv4}/)   { say "adresse IPv4"; } 
  when (/$RE{net}{domain}/) { say "FQDN"; } 
  default                   { say "type d'argument inconnu"; } 
}

• un when réussi termine le given correspondant ;
• un break permet de sortir du given ;
• un continue permet d'aller au when suivant ;
• default est lu si rien d'autre ne correspond.
  

1
2
3
4
5
6
7
8
use Switch; 
  
switch ($string) { 
  case /^abc/ { $abc     = 1; } 
  case /^def/ { $def     = 1; } 
  case /^xyz/ { $xyz     = 1; } 
  else        { $nothing = 1; } 
}

Plusieurs formes de parcours de boucles, de répétitions ou d'itérations sont disponibles. Elles sont à adapter en fonction des besoins. Le but est toujours de parcourir un bloc de code tant que certaines conditions sont vérifiées, ou bien un certain nombre de fois, ou bien pour toutes les valeurs d'une liste, comme les fonctions map et grep.

Ce sont les boucles qui exigent une condition de sortie. On y trouve les boucles avec une condition permanente :

1
2
3
4
while (condition) 
  { 
    # bloc d'instructions 
  }

1
2
3
4
until (condition) 
  { 
    # bloc d'instructions 
  }

instruction while (condition);

instruction until (condition);

Ce sont des boucles pour lesquelles une variable sert à dénombrer les itérations et à arrêter la répétition lorsqu'une valeur donnée est atteinte. La syntaxe est alors :

1
2
3
4
for (initialisation ; condition ; incrementation) 
{ 
  # bloc d'instructions 
}

1
2
3
for ($i=0 ; $i<10 ; $i++) { 
  print "$i\n"; 
}

1
2
3
for (($i, $j)=(0, 10) ; $i<10 ; ($i++,$j--)) { 
  print "[$i,$j]\n"; 
}

1
2
3
4
5
initialisation 
while (condition) { 
  # bloc d'instructions 
  incrémentation 
}

Il est possible de parcourir la totalité des éléments d'une liste, et pas seulement au moyen des instructions map et grep. La fonction each() est destinée aux énumérations de tableaux associatifs. Elle prend une table de hachage comme argument et retourne une clef de cette table. A l'appel suivant, elle retournera la clef suivante. Et ainsi de suite jusqu'à épuisement des clefs. On voit bien qu'intégrée à une boucle while/until ou for, cette fonction peut énumérer tous les éléments d'un hachage. L'autre construction d'énumération très utilisée est la boucle foreach. La syntaxe complète est :

1
2
3
foreach $variable ( @liste ) { 
  # bloc d'instructions 
}

1
2
3
4
foreach ( @liste ) { 
  # bloc d'instructions 
  # l'élément en cours est $_ 
}

1
2
3
4
5
6
7
8
9
10
11
12
# liste des sentences pour chaque pétale possible (6 x 10) 
my @marguerite = ( 'je t\'aime', 'un peu', 'beaucoup', 'passionnément', 'à la folie', 'pas du tout' ) x 10; 
  
# Tirage du nombre de pétales, de 0 à 59 
my $i = int( rand(59) ); 
  
# Pour tous les pétales... 
foreach ( 0 .. $i ) { 
  
  # On effeuille la marguerite 
  print $marguerite[$_] . "\n"; 
}

Un programme avec un bon algorithme se déroule normalement sans problème. Tous les cas sont prévus dans les alternatives, les boucles sont bien conçues et tout est pour le mieux. Cependant, il arrive que des changements dans les traitements, au cours de la maintenance du code, ou bien des difficultés imprévues de conception, obligent le programmeur à introduire des conditions particulières de rupture des structures de contrôle. Ces ruptures ne sont pas un signe de bonne conception... plutôt le signe qu'une modification, apparemment bénigne qui aurait eu de grosses répercussions sur la structure du code et qu'il a été préférable d'en limiter l'ampleur par un petit traitement localisé.

• redo est l'instruction de rupture qui permet de reprendre l'itération en cours au début du bloc de code ;
• next est l'instruction qui permet de passer à l'itération suivante. Elle effectue un saut direct à la fin du bloc de code ;
• last est l'instruction qui permet d'arriver directement à la fin de la dernière itération. On sort des traitements/boucles et on continue l'exécution du programme aux instructions qui suivent.
  

1
2
3
4
5
6
EXTERNE: foreach $i ( 0 .. 10 ) { 
  INTERNE: foreach $j ( 0 .. 10 ) { 
      next EXTERNE if ( ( $i + $j ) > 10 ); 
      print "i=$i - j=$j\n"; 
  } 
}

Il existe aussi une instruction goto qui permet de faire un saut dans l'exécution du code, jusqu'à une étiquette donnée (fixée à l'écriture du programme, ou évaluée dynamiquement. Utiliser ce type d'instruction n'est pas vraiment une bonne idée. Le langage étant par ailleurs riche en structures de contrôles et en instructions de ruptures, l'usage de cette instruction peut être carrément néfaste, à la maintenance du code si ce n'est à son exécution.

Puisque les sauts sont déconseillés dans le contrôle du flux d'exécution du programme, il existe une structure "idoine" qui permet d'abandonner le bloc courant pour exécuter un autre bloc de code et revenir ensuite à notre point de "digression". C'est la notion de sous-routine, procédure ou fonction. Cela permet d'écrire une seule fois un bloc de code qui sera exécuté à de nombreuses reprises dans un programme, depuis plusieurs endroits différents. Une fonction se déclare avec le mot-clef "sub", suivi du nom de la fonction, suivi du bloc de code à exécuter :

1
2
3
sub a_la_trace { 
  print "Tout passage par la fonction est suivi a_la_trace\n"; 
}

1
2
3
4
5
print "Début"; 
a_la_trace(); 
print "Milieu"; 
a_la_trace(); 
print "Fin";

La fonction ainsi définie peut aussi admettre des paramètres. Perl n'étant pas très strict ni rigide, il peut même laisser le nombre de paramètres des fonctions totalement libre. Une fonction qui admet des paramètres s'appelle en précisant les paramètres entre parenthèses après le nom de la fonction :

1
2
3
4
5
print "Début"; 
A_la_trace("Début", "Milieu"); 
print "Milieu"; 
A_la_trace("Milieu", "Fin"); 
print "Fin";

Lors de l'appel à une fonction, Perl range les paramètres dans une liste spéciale, "@_", interne à la fonction. Cette liste se comporte comme toutes les autres. Il n'est, par contre, pas recommandé de tenter de la modifier. Il est donc possible de récupérer les valeurs de différentes façons :

my ($param1, $param2) = @_;

my ($param1) = @_;

my $param = shift;

1
2
3
my $nombre_arguments = @_;  
# ou bien  
my $nombre_arguments = scalar @_;

On l'a vu, à la réception dans la fonction, les paramètres sont rangés dans une liste. Si lors de l'appel on a spécifié une liste comme paramètre de la fonction, celle-ci va s'aplatir dans la liste @_. Pour conserver le caractère "liste" des paramètres, il faut passer par la notion de référence, qui sera vue ultérieurement. De même, si l'on souhaite modifier la valeur des paramètres, les références pourront nous aider.

Une fonction se termine dans deux cas :

• la fin du bloc de code de la fonction est atteinte. Retour à l'appelant ;
• une instruction return est rencontrée. Retour à l'appelant, mais on lui transmet les valeurs qui suivent le mot-clef return.
  

Perl vous permet de définir une fonction particulière qui sera appelée si l'utilisateur tente d'invoquer une fonction non définie dans le paquetage (l'espace de nom). Cette fonction particulière s'appelle AUTOLOAD. Si elle est appelée, une variable globale au paquetage nommée $AUTOLOAD, qui contiendra le nom de la fonction que l'on a essayé d'appeler, sera créée. Attention, pour utiliser cette variable, il faut la déclarer avec our, on ne peut pas l'utiliser sans la déclarer. Par exemple, si l'on veut signaler que la fonction appelée par l'utilisateur n'existe pas sans pour autant faire boguer le programme, on peut le faire ainsi :

1
2
3
4
sub AUTOLOAD { 
	our $AUTOLOAD; 
	print "La fonction $AUTOLOAD n'a pas été définie !"; 
}

La fonction AUTOLOAD permet de créer votre propre Shell en quelques lignes :

1
2
3
4
5
6
sub AUTOLOAD { 
	my $fonc = our $AUTOLOAD; 
	$fonc =~ s/.*:://; #on enlève le nom du paquetage et les :: 
	system($fonc, @_) #appelle $fonc avec la liste d'arguments passée à AUTOLOAD 
} 
cd (mount) #appelle la fonction système cd en lui passant mount en paramètre