Programmation Perl/Fonctions et procédures

Introduction

Quelques définitions

Déjà, il est bon de savoir ce qu'est une fonction. Une fonction permet de factoriser du code, si on a besoin d'exécuter une même portion de code à des endroits différents, ou pour simplifier la lecture d'un code, il est préférable de séparer certaines instructions et d'y faire appel le moment venu.

Petit instant vulgarisation : un exemple simple pour se représenter ce qu'est une fonction est de s'imaginer toutes les actions que nous avons besoin de faire pour aller faire les courses au marché. Vous dites « aller faire les courses » et pas « prendre mes clés, mon argent, sortir de chez moi, fermer la porte, prendre la voiture … ». Une fonction permet donc ceci: « s'abstraire » de toutes les actions entre le moment où vous partez et le moment où vous revenez. Ce qu'il faut pour que cette série d'action se déroule bien, ce serait avoir un peu d'argent ; prenez ceci comme exemple de paramètre. Pour aller faire les courses (la fonction), il faut un peu d'argent (paramètre de la fonction), et à la fin vous avez vos courses (retour de fonction).

Ce qu'est une fonction en Perl

En Perl, il y a plusieurs manières d'appeler ou même de faire des fonctions, tout comme il y a plusieurs manières de tout faire. Il n'y a pas forcément une méthode meilleure que l'autre, si ce n'est au niveau de la visibilité du point de vue d'un œil non averti.

Nous commencerons à voir comment se fait l'appel d'une fonction (que nous avons vu sans en parler jusque-là), puis comment créer sa propre fonction et comment récupérer les paramètres.

À savoir : généralement en Perl nous parlons de « routine » pour dire une fonction que vous créez vous-même. Le mot « fonction » est généralement utilisé pour parler des fonctions intégrées directement dans le langage.

Les appels de fonction

Nous avons déjà vu comment appeler une fonction, par exemple :

say "hello !";

Ici nous avons un appel à la fonction "say" et nous passons en paramètre "hello !". Plus classiquement dans les autres langages, des parenthèses sont utilisées pour distinguer la fonction de ses paramètres, ceci donnerait :

say( "hello !");

En Perl, il n'y a pas d'obligation. Pour passer plusieurs paramètres, Pour enchaîner plusieurs fonctions à la suite, il est parfois nécessaire de mettre des parenthèses pour lever l'ambigüité sur quels sont les paramètres utilisés pour quelle fonction.

say "début de ligne " , join ':', qw/mots du milieu/ , " fin de ligne."
# début de ligne mots:du:milieu: fin de ligne.

Si on cherche à écrire cette fonction de manière plus claire, ceci donne :

say("début de ligne ", join(':', qw/mots du milieu/, " fin de ligne."));

On remarque plus facilement la différence entre les paramètres de say et ceux de join. Aussi, si on avait envie que join ne prenne que ':' et qw/mots du milieu/ en paramètre, il aurait fallu écrire :

say "début de ligne ", join(':', qw/mots du milieu/), " fin de ligne.";

Assez souvent une fonction renvoie une valeur. Dans l'exemple précédent, la fonction join renvoie une chaîne de caractères (un scalaire) et on réutilise tout de suite cette valeur comme paramètre à l'appel de la fonction say. On aurait évidemment pû récupérer cette valeur :

my $chaine = join(':', qw/mots du milieu/);
say "début de ligne ", $chaine , " fin de ligne.";

Créer une fonction

Syntaxe

Cela se fait avec le mot clé sub (pour « subroutine » ) suivit du nom que vous souhaitez donner à la fonction, puis d'un bloc de code. La syntaxe la plus simple est :

sub nom_de_la_fonction 
{
        # instructions
}

Il n'y a pas de règle pour le placement des accolades, vous pouvez très bien mettre l'accolade ouvrante sur la même ligne que le nom de la fonction que vous créez si vous trouvez ça plus naturel.

Récupérer des paramètres envoyés à la fonction

Maintenant on va vouloir passer des paramètres à notre fonction. Il faut savoir qu'en Perl, il n'y a pas besoin d'indiquer les paramètres d'une fonction.

Pour récupérer les paramètres d'une fonction, vous pouvez prendre les valeurs qui se trouvent dans la variable spéciale @_. Cette variable fait partie des variables qui changent au cours du temps, en fonction du moment où elles sont appelés. Dans ce contexte (rien à voir avec les contextes des variables), @_ vaut simplement la liste de paramètres que vous envoyez à votre fonction. Comme cette variable change au cours du temps, il est préférable d'en faire une copie dans un tableau en tout début de fonction, pour récupérer les paramètres et être sûr de pouvoir les réutiliser par la suite.

sub afficher {
        my @s = @_; # @_ contient actuellement tous les paramètres envoyés à la fonction
        say join ' : ' , @s;
}
afficher("test");

Donc tout ce que vous avez à faire pour récupérer des paramètres c'est de récupérer @_. À savoir qu'il y a quelques petites astuces à connaître pour récupérer des paramètres facilement. Prenons un exemple, une fonction qui fait une addition (et prend 2 paramètres) et affiche le résultat :

sub addition
{
        my ($a, $b) = @_;
        my $resultat = $a + $b;
        say $resultat;
}

Ici on peut voir qu'il y a des parenthèses autour des deux variables $a et $b ; ceci est pour forcer le contexte de liste. S'il y a plus de deux éléments dans @_ alors ils seront ignorés.

Retour de valeur

Pour que la fonction retourne une valeur, il suffit d'utiliser le mot clé return. On peut renvoyer un scalaire, une liste (tableau, table de hachage…).

sub renvoyer_une_chaine 
{
        return "Cette fonction renvoie une chaîne de caractères";
}
say renvoyer_une_chaine ; # affichage de la valeur de retour de la fonction

Il est possible également de renvoyer plusieurs valeurs, elles seront renvoyés dans une liste et la récupération de ces valeurs peut se faire comme pour la récupération des paramètres dans une fonction.

sub addition
{
        my ($a, $b) = @_;
        my $resultat = $a + $b;
        return $a, $b, $resultat;
}

my ($a, $b, $resultat) = addition(5,6);
say "$a + $b = $resultat"; # 5 + 6 = 11

Pour renvoyer plusieurs résultats, il suffit de séparer les variables par des virgules, ce qu'on fait généralement pour séparer des paramètres à l'appel d'une fonction par exemple.