view release on metacpan or  search on metacpan

FR/perlsub.pod  view on Meta::CPAN

Parfois, vous ne voulez pas passer la valeur d'un tableau à un
sous-programme mais plutôt son nom, pour que le sous-programme puisse
modifier sa copie globale plutôt que de travailler sur une copie
locale. En perl, vous pouvez vous référer à tous les objets d'un nom
particulier en préfixant ce nom par une étoileE<nbsp>: C<*foo>. Cela est
souvent connu sous le nom de "typeglob", car l'étoile devant peut être
conçue comme un caractère générique correspondant à tous les drôles de
caractères préfixant les variables et les sous-programmes et le reste.

Lorsqu'il est évalué, le typeglob produit une valeur scalaire qui
représente tous les objets portant ce nom, y compris tous les handles
de fichiers, les formats, ou les sous-programmes. Quand on l'affecte,
le nom mentionné se réfère alors à la valeur C<*> qui lui a été
affectée, quelle qu'elle soit. ExempleE<nbsp>:

    sub doubleary {
        local(*someary) = @_;
        foreach $elem (@someary) {
            $elem *= 2;
        }
    }
    doubleary(*foo);
    doubleary(*bar);

Les scalaires sont déjà passés par référence, vous pouvez donc
modifier les arguments scalaires sans utiliser ce mécanisme en vous
référant explicitement à C<$_[0]>, etc. Vous pouvez modifier tous les
éléments d'un tableau en passant tous les éléments comme des
scalaires, mais vous devez utiliser le mécanisme C<*> (ou le mécanisme
de référencement équivalent) pour effectuer des C<push>, des C<pop>,
ou changer la taille d'un tableau. Il sera certainement plus rapide de
passer le typeglob (ou la référence).

Même si vous ne voulez pas modifier un tableau, ce mécanisme est
utile pour passer des tableaux multiples dans une seule LIST, car
normalement le mécanisme LIST fusionnera toutes les valeurs de
tableaux et vous ne pourrez plus en extraire les tableaux
individuels. Pour plus de détails sur les typeglobs, voir
L<perldata/"Typeglobs et handles de fichiers">.

=head2 Quand faut-il encore utiliser local()

Malgré l'existence de C<my>, il y a encore trois endroits où
l'opérateur C<local> brille toujours. En fait, en ces trois endroits,
vous I<devez> utiliser C<local> à la place de C<my>.

=over 4

=item 1.

Vous avez besoin de donner une valeur temporaire à une variable
globale, en particulier $_.

Les variables globales, comme C<@ARGV> ou les variables de
ponctuation, doivent être C<local>isées avec C<local()>. Ce bloc lit
dans F</etc/motd>, et le découpe en morceaux, séparés par des lignes de
signes égal, qui sont placés dans C<@Fields>.

    {
        local @ARGV = ("/etc/motd");
        local $/ = undef;
        local $_ = <>;  
        @Fields = split /^\s*=+\s*$/;
    } 

Il est important en particulier de C<local>iser $_ dans toute routine
qui l'affecte. Surveillez les affectations implicites dans les
conditionnelles C<while>.

=item 2.

Vous avez besoin de créer un handle de fichier ou de répertoire local,
ou une fonction locale.

Une fonction ayant besoin de son propre handle de fichier doit
utiliser C<local()> sur le typeglob complet. Ceci peut être utilisé
pour créer de nouvelles entrées dans la table des symbolesE<nbsp>:

    sub ioqueue {
        local  (*READER, *WRITER);    # pas my !
        pipe    (READER,  WRITER)     or die "pipe: $!";
        return (*READER, *WRITER);
    }
    ($head, $tail) = ioqueue();

Voir le module Symbol pour une façon de créer des entrées de table de
symboles anonymes.

Puisque l'affectation d'une référence à un typeglob crée un alias,
ceci peut être utilisé pour créer ce qui est effectivement une
fonction locale, ou au moins un alias local.

    {
        local *grow = \&shrink; # seulement jusqu'à la fin de
                                # l'existence de ce bloc
        grow();                 # appelle en fait shrink()
        move();                 # si move() grandit, il rétrécit
                                # aussi
    }
    grow();                     # récupère le vrai grow()

Voir L<perlref/"Modèles de fonctions"> pour plus de détails sur la
manipulation des fonctions par leur nom de cette manière.

=item 3.

Vous voulez changer temporairement un seul élément d'un tableau ou
d'un hachage.

Vous pouvez C<local>iser juste un élément d'un aggrégat.
Habituellement, cela est fait dynamiquementE<nbsp>:

    {
        local $SIG{INT} = 'IGNORE';
        funct();                            # impossible à interrompre
    } 
    # la possibilité d'interrompre est restaurée ici

Mais cela fonctionne aussi sur les aggrégats déclarés
lexicalement. Avant la version 5.005, cette opération pouvait parfois