5. Les fonctions

5.1 Présentation

La structure générale d'une fonction est:

        sub fonction
        {
                # block
        }

block est le corps de la fonction, c'est à dire les actions à exécuter. Chaque action est séparée d'une autre par ';'. Le caractère '#' permet de commenter le code écrit. Tout ce qui suit ce caractère jusqu'au prochain retour à la ligne n'est pas interprété.

5.2 Création d'une fonction

        sub hello
        {       
                print "Hello World !\n";
        }


        hello();        # affiche 'Hello World !\n'
        hello;          # idem
        &hello;     # idem
        do hello;       # idem

L'exemple précédent nous montre comment créer une fonction et comment l'exécuter de quatre manières différentes.

5.3 Valeur de retour d'une fonction

        sub true
        {
                return 1;
        }

        $t = true;              # $t vaut 1;
        $t = true();            # idem 

La fonction suivante est équivalente:

        sub true
        {
                1;
        }

        $t = true;      # $t vaut 1

Les deux exemples ci-dessus sont équivalents. En fait Perl retourne la valeur de la dernière expression de la fonction exécutée. Cette valeur n'est pas seulement entière. Il est possible de retourner des tables ou des tables de hash.

        sub foo
        {
                ...
                ...
                @tab = (1, 2, 3);
                return @tab;    # ou return (1, 2, 3);
        }

        sub bar
        {
                ...
                ...
                %hash = (
                                'i' => 1,
                                'ii' => 2,
                        );
        
                %hash;
        }

Losque return est manquant, la valeur de la dernière expression est retournée.

5.4 Arguments d'une fonction

Les arguments d'une fonction se présentent sous la forme d'une table. Elle est notée @_. Donc:

        $_[0];          # premier argument.
        $_[$#_];        # dernier argument :
                        # $#_ est le dernier indice dans le tableau

Bien souvent on connait à l'avance le nombre d'arguments d'une fonction. Aussi on privilégiera l'usage de @_ à $_[0], etc.

        sub sum
        {
                $sum = 0;
                foreach (@_) # parcours de tous les arguments
                {
                        $sum += $_;
                }
                $sum;
        }


        sum(10, 20, 30, "40");          # retourne 100

Rappel: Perl fait les conversions implicitement.

        sub hello
        {
                ($nom, $prenom) = @_;

                print "Hello $nom $prenom\n";
        }

        hello("FORCIOLI", "Alain");     # affiche 'Hello FORCIOLI Alain\n'

Cet usage est préférable car il évite une ligne complexe du genre:

        ($nom, $prenom) = ($_[0], $_[1]);

5.5 Variables locales

Il existe deux fonctions qui permettent de rendre locale une variable.

        $a = "a";                       
        {
                local($a) = "b";        # $a est locale au 'scope' 
                                        # (par exemple: {...})
                print "$a\n";           # affiche 'b\n'
        }

        print "$a\n";                   # affiche 'a\n'

L'exemple précédent montre que les variables $a ont des valeurs différentes. La seconde déclaration (utilisant local() pour définir $a) rend $a visible uniquement à l'intérieur des crochets. Nous avons deux espaces de noms en notre présence. Dans le premier nous avons $a valant a, dans le second nous avons $a égale à b.

Le manuel (section perlfunc) préconise tout de même l'emploi de my(), qui apparemment donne un sens plus fort au terme locale. En effet dans un contexte orienté objet ou de module, une variable déclarée avec local, est connue de tout le scope (scope : espace de nommage, compris entre crochets) de module ou de la classe. Tandis qu'une variable déclarée avec my est connue uniquement à l'intérieur du scope ou elle est définie.