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.