view release on metacpan or  search on metacpan

FR/perlfunc.pod  view on Meta::CPAN

    # tri stable, sans choix de l'algorithme
    use sort 'stable';
    @new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;

    # utilisation forcée d'un mergesort (non portable en dehors de Perl 5.8)
    use sort '_mergesort';  # notez le _ décourageant
    @new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;

Si vous utilisez strict, vous I<NE DEVEZ PAS> déclarer C<$a> et C<$b> comme
variables lexicales. Ce sont des variables globales au package. Cela signifie
que si vous êtes dans le package C<main>, S<c'est :>

    @articles = sort {$main::b <=> $main::a} @files;

ou S<juste :>

    @articles = sort {$::b <=> $::a} @files;

mais si vous êtes dans le package C<FooPack>, <c'est :>

    @articles = sort {$FooPack::b <=> $FooPack::a} @files;

La fonction de comparaison doit se comporter correctement. Si elle retourne
des résultats incohérents (parfois elle dit que C<$x[1]> est plus petit que
C<$x[2]> et d'autres fois le contraire par exemple), le résultat du tri n'est
pas bien défini.

Puisque C<< <=> >> retourne C<undef> lorsque l'un de ses opérandes est
C<NaN> (not-a-number, pas un nombre) et puisque C<sort> provoque une
erreur fatale si le résultat d'une comparaison n'est pas défini,
lorsque vous triezeffectuez un tri en utilisant une fonction de
comparaison comme C<< $a <=> $b >>, faites attention aux listes
contenant un C<NaN>. L'exemple suivant exploite le fait que C<NaN !=
NaN> pour éliminer les C<NaN> de @input.

  @result = sort { $a <=> $b } grep { $_ == $_ } @input;

=item splice TABLEAU,OFFSET,LONGUEUR,LISTE
X<splice>

=item splice TABLEAU,OFFSET,LONGUEUR

=item splice TABLEAU,OFFSET

=item splice TABLEAU

Supprime d'un tableau les éléments consécutifs désignés par OFFSET (indice du
premier élément) et LONGUEUR (nombre d'éléments concernés) et les remplace par
les éléments de LISTE si il y en a. Dans un contexte de liste, renvoie les
éléments supprimés du tableau. Dans un contexte scalaire, renvoie le dernier
élément supprimé ou C<undef> si aucun élément n'est supprimé. Le tableau
grossit ou diminue si nécessaire. Si OFFSET est négatif, il est compté à
partir de la fin du tableau. Si LONGUEUR est omis, supprime tout à partir de
OFFSET. Si LONGUEUR est négatif, supprime les éléments à partir de OFFSET en
laissant -LONGUEUR éléments à la fin du tableau. Si OFFSET et LONGUEUR sont
omis, supprime tout ce qui est dans le tableau. Si OFFSET va au-delà de la fin
du tableau, perl produit un message d'avertissement et splice agit à la fin du
tableau.

Les équivalences suivantes sont vraies en supposant que
S<<C<<$[ == 0 and $#a >= $i>> :>>

    push(@a,$x,$y)      splice(@a,@a,0,$x,$y)
    pop(@a)             splice(@a,-1)
    shift(@a)           splice(@a,0,1)
    unshift(@a,$x,$y)   splice(@a,0,0,$x,$y)
    $a[$i] = $y         splice(@a,$i,1,$y)

Exemple, en supposant que la longueur des tableaux est passée avant chaque
S<tableau :>

    sub aeq {   # compare deux listes de valeurs
        my(@a) = splice(@_,0,shift);
        my(@b) = splice(@_,0,shift);
        return 0 unless @a == @b;       # même longueur ?
        while (@a) {
            return 0 if pop(@a) ne pop(@b);
        }
        return 1;
    }
    if (&aeq($len,@foo[1..$len],0+@bar,@bar)) { ... }

=item split /MOTIF/,EXPR,LIMITE
X<split>

=item split /MOTIF/,EXPR

=item split /MOTIF/

=item split

Découpe la chaîne EXPR en une liste de chaînes et la retourne. Par
défaut, les champs vides du début sont conservés et ceux de la fin
sont éliminés (si tous les champs sont vides, ils sont considérés
comme étant à la fin).

Si l'appel n'est pas dans un contexte de liste, split retourne le nombre de
champs trouvés et les place dans le tableau C<@_>. (Dans un contexte de liste,
vous pouvez forcer l'utilisation du tableau C<@_> en utilisant C<??> comme
motif délimiteur mais il renvoie encore la liste des valeurs.) En revanche,
l'utilisation implicite de C<@_> par split est désapprouvée parce que cela
écrase les arguments de votre subroutine.

SI EXPR est omis, split découpe la chaîne C<$_>. Si MOTIF est aussi omis, il
découpe selon les blancs (après avoir sauté d'éventuels blancs au
départ). Tout ce qui reconnu par MOTIF est considéré comme étant un délimiteur
de champs. (Remarquez que le délimiteur peut être plus long qu'un seul
caractère.)

Si LIMITE est spécifié et positif, fixe le nombre maximum de champs du
découpage (le nombre de champs dépend du nombre de fois où le MOTIF sera
reconnu dans EXPR). Si LIMITE n'est pas spécifié ou vaut zéro, les champs
vides de la fin sont supprimés (chose dont les utilisateurs potentiels de
C<pop()> devraient se souvenir). Si LIMITE est négatif, il est traité comme si
LIMITE avait une valeur arbitrairement très grande. Notez que découper une
EXPR dont la valeur est la chaîne vide retourne toujours une liste vide, que
LIMIT soit spécifié ou non.

Un motif qui peut correspondre à la chaîne vide (ne pas confondre avec
le motif vide C<//> qui n'est qu'un motif parmi tous ceux qui peuvent
correspondre à la chaîne vide) découpera la valeur de EXPR en