Sous-programmes
Les sous-programmes se définissent par l'instruction sub, et sont appelés en faisant précéder leur nom du caractère &. Exemple :
...;
&sousprog;
...;
sub sousprog {
...;
}
La valeur de retour d'un sous-programme est la valeur de la dernière expression évaluée par ce dernier. On peut par exemple l'affecter à une variable (ou à une liste ...) avec l'instruction
$var = &sousprog;
ou
@liste=&sous_prog_qui_retourne_une_liste;
Dans le cas où une boucle à expression conditionnelle est effectuée dans le sous-programme, il faut tenir compte du fait que la dernière expression évaluée est ladite expression conditionnelle, et non la dernière instruction de la boucle. Il faut introduire une nouvelle variable définie après la sortie de la boucle ... Exemple :
#!/bin/perl
$nblign = &affich ;
print ("Nombre de lignes contenant abc = $nblign.\n") ;
sub affich {
$compt = 0 ;
ETIQ:$line =
<STDIN>;
while ($line ne
"") {
if ($line =~ /abc/) {
$compt++ ;
}
goto ETIQ ;
}
}
Ce programme permet d'afficher, en utilisant les
étiquettes, le nombre de lignes contenant le
modèle abc
. Mais cette version ne
fonctionne pas, car la dernière expression
évaluée dans le sous-programme affich est
l'expression conditionnelle ($line ne "")
, ce
qui renvoie une chaîne vide. Si, en revanche, on prend soin
d'introduire une variable additionnelle, comme suit :
#!/bin/perl
$nblign = &affich ;
print ("Nombre de lignes contenant abc = $nblign.\n") ;
sub affich {
$compt = 0 ;
ETIQ:$line =
<STDIN>;
while ($line ne "") {
if ($line =~ /abc/) {
$compt++ ;
}
goto ETIQ ;
}
$var = $compt ;
}
alors la dernière expression
évaluée sera $compt
, qui
sera la valeur (souhaitée) de retour du sous-programme.
Instruction return
Elle constitue un autre moyen de s'assurer que le sous-programme retourne la valeur que l'on souhaite. La syntaxe :
return(valeur_retour);
permet de retourner au choix une chaîne, une variable scalaire ou une liste.
Passage d'arguments à des sous-programmes
Le passage d'arguments se fait au moment de l'appel du sous-programme, comme l'illustre le programme suivant qui fait la somme de trois entiers :
#!/bin/perl
$v1 = 1 ;
$v2 = 2 ;
$v3 = 3 ;
$total=&calcul_somme($v1,$v2,$v3) ;
print ("total = $total\n") ;
sub calcul_somme {
my($n1,$n2,$n3) = @_ ;
$somme = $n1 + $n2 + $n3 ;
}
La variable système @_ contient la liste des
arguments passés au sous-programme. On constate que les
variables $n1
, $n2
et $n3
ont des identifiants
différents des variables $v1
, $v2
et $v3
du programme principal. L'instruction my
utilisée dans la première ligne du sous-programme
peut être utilisée pour préciser que
ces variables ne sont que locales et doivent être
détruites après appel du sous-programme.
La variable @_ peut être utilisée comme n'importe quelle autre variable tableau, et on n'a donc pas en toute rigueur à définir les variables locales. Le sous-programme suivant aura le même fonctionnement, même si la lecture en est un peu plus difficile :
#!/bin/perl
$v1 = 1 ;
$v2 = 2 ;
$v3 = 3 ;
$total=&calcul_somme($v1,$v2,$v3) ;
print ("total = $total\n") ;
sub calcul_somme {
$somme = @_[0] + @_[1] +
@_[2] ;
}
On peut également passer un tableau en argument d'un sous-programme, exactement de la même manière que ci-dessus :
&sous_prog(@tab);
sub sous_prog {
my (@tableau)=@_;
}
Dans ce cas, Perl fait une copie du tableau initial. Si le tableau est grand, la perte de temps peut être conséquente. On peut alors décider de travailler sur le tableau lui-même, en le passant par son nom :
sub sous_prog {
my (*tableau)=@_;
}
C'est le caractère * devant le nom local du tableau qui indique à l'interpréteur de ne pas faire de copie. L'appel se fera de la manière suivante :
&sous_prog(*tab);
Une modification du tableau dans le sous-programme entraîne alors la modification du tableau passé en argument.
Récursivité
On peut appeler un sous-programme à partir d'autres sous-programmes, ou à partir du sous-programme même, ce qui permet de faire des programmes récursifs.
Sous-programmes prédéfinis
Comme awk, Perl 5 définit les sous-programmes BEGIN
et END, qui sont exécutés respectivement au
début et à la fin du programme principal. Il en
existe également un troisième, AUTOLOAD, qui est
appelé lorsque Perl ne parvient pas à trouver un
sous-programme qu'il est censé exécuter. La
variable spéciale $AUTOLOAD contient le nom du
sous-programme que l'on a essayé d'appeler.