view release on metacpan or  search on metacpan

FR/perlop.pod  view on Meta::CPAN

=head2 Opérateur et bit à bit X<opérateur, bit à bit, et> X<et bit a bit> X<&>

L'opérateur binaire "&" renvoie le résultat d'un ET bit à bit entre ses
opérandes. (Voir aussi L<Arithmétique entière> et L<Opérateurs bit à bit sur
les chaînes>.)

Notez que "&" a une priorité plus faible que les opérateurs de
comparaison si bien que les parenthèses sont indispensables dans un
test comme S<ci-dessous :>

     print "Pair\n" if ($x & 1) == 0;

=head2 Opérateurs ou et ou exclusif bit à bit X<opérateur, bit à bit, ou> X<opérateur, bit à bit, ou exclusif> X<ou bit à bit> X<ou exclusif bit à bit> X<^> X<|>

L'opérateur binaire "|" renvoie le résultat d'un OU bit à bit entre ses deux
opérandes. (Voir aussi L<Arithmétique entière> et L<Opérateurs bit à bit sur
les chaînes>.)

L'opérateur binaire "^" renvoie le résultat d'un OU EXCLUSIF (XOR) bit à bit
entre ses deux opérandes. (Voir aussi L<Arithmétique entière> et L<Opérateurs
bit à bit sur les chaînes>.)

Notez que "|" et "^" ont une priorité plus faible que les opérateurs
de comparaison si bien que les parenthèses sont indispensables dans un
test comme S<ci-dessous :>

   print "faux\n" if (8 | 2) != 10;

=head2 Et logique style C X<&&> X<et logique> X<opérateur, logique, et>

L'opérateur binaire "&&" calcule un ET logique rapide. Cela signifie que si
l'opérande gauche est faux, l'opérande droit n'est même pas évalué. Le
contexte scalaire ou de liste se propage vers l'opérande droit si il est
évalué.

=head2 Défini-ou logique style C X<//> X<opérateur, logique, défini-ou>

Bien que n'ayant pas d'équivalent direct en C, l'opérateur Perl C<//>
s'apparente à un ou style C. En fait, c'est exactement la même chose
que C<||> sauf qu'il ne teste pas la véracité de son opérande gauche
mais le fait qu'il soit défini. Donc, C<$a // $b> est similaire à
C<defined($a) || $b> (sauf qu'il retourne la valeur de C<$a> au lieu
de la valeur de C<defined($a)>) et est exactement équivalent à
C<defined($a) ? $a : $b>. C'est très pratique pour donner des valeurs
par défaut à des variables. On peut aussi tester si au moins l'une des
variables C<$a> ou C<$b> est définie en écrivant C<defined($a // $b)>.

=head2 Ou logique style C X<||> X<ou logique> X<opérateur, logique, ou>

L'opérateur binaire "||" calcule un OU logique rapide. Cela signifie que si
l'opérande gauche est vrai, l'opérande droit n'est même pas évalué. Le
contexte scalaire ou de liste se propage vers l'opérande droit si il est
évalué.

Les opérateurs C<||>, C<//> et C<&&> renvoient la dernière valeur
évaluée (contrairement aux homologues en C, C<||> et C<&&> qui
renvoient 0 ou 1). Donc, un moyen raisonnablement portable de trouver
le répertoire home peut S<être :>

   $home = $ENV{HOME} // $ENV{LOGDIR} //
     (getpwuid($<))[7] // die "You're homeless!\n";

En particulier, cela signifie que vous ne devriez pas les utiliser pour
choisir entre deux agrégats dans une <affectation :>

    @a = @b || @c;              # c'est pas bon
    @a = scalar(@b) || @c;      # voila ce que ça signifie
    @a = @b ? @b : @c;          # cela marche très bien par contre

Pour remplacer d'une manière plus lisible l'usage de C<&&>, C<//> et
C<||> pour contrôler un flot d'opérations, Perl propose les opérateurs
C<and>, C<err> et C<or> (voir plus bas). Le comportement d'évaluation
rapide est le même. En revanche, comme la priorité de "and", "err" et
"or" est plus faible, vous pouvez les utiliser après les opérateurs de
listes sans ajouter de S<parenthèses :>

    unlink "alpha", "beta", "gamma"
            or gripe(), next LINE;

Avec les opérateurs à la C, vous auriez dû S<l'écrire :>

    unlink("alpha", "beta", "gamma")
            || (gripe(), next LINE);

En revanche, l'utilisation de "or" lors d'une affectation ne donne pas ce que
vous voulez; voir plus bas.

=head2 Opérateurs d'intervalle X<opérateur, intervalle> X<intervalle> X<..> X<...>

L'opérateur binaire ".." est l'opérateur d'intervalle qui est en fait
deux opérateurs totalement différents selon le contexte. Dans un
contexte de liste, il renvoie une liste de valeurs commençant à la
valeur de son opérande gauche et se terminant à la valeur de son
opérande droit (par pas de 1). Si la valeur de gauche est plus petite
que la valeur de droite, il retourne une liste vide. C'est pratique
pour écrire des boucles C<foreach (1..10)> et pour des opérations de
remplacement sur des tableaux. Dans l'implémentation actuelle, aucun
tableau temporaire n'est généré lorsque l'opérateur d'intervalle est
utilisé comme expression de boucles C<foreach> mais les vieilles
versions de Perl peuvent consommer énormément de mémoire lorsque vous
écrivez quelque chose S<comme :>

    for (1 .. 1_000_000) {
        # code
    }

L'opérateur d'intervalle fonctionne aussi avec des chaînes de
caractères, en utilisant l'auto-incrémentation (voir ci-dessous).

Dans un contexte scalaire, ".." renvoie une valeur booléenne. L'opérateur est
bi-stable comme un interrupteur et simule l'opérateur d'intervalle de ligne
(virgule) de B<sed>, de B<awk> et d'autres éditeurs. Chaque opérateur ".."
conserve en mémoire son propre état booléen. Il reste faux tant que son
opérande gauche est faux. Puis dès que son opérande gauche devient vrai, il
reste vrai jusqu'à ce que son opérande droit soit vrai. I<APRÈS> quoi,
l'opérateur d'intervalle redevient faux. Il ne redevient faux que le prochaine
fois que l'opérateur d'intervalle est évalué. Il peut tester l'opérande droit
et devenir faux lors de la même évaluation où il devient vrai (comme dans
B<awk>) mais il retournera encore une fois vrai. Si vous ne voulez pas qu'il
teste l'opérande droit avant la prochaine évaluation (comme dans B<sed>),
utilisez trois points ("...") à la place de deux. Pour tout le reste, "..." se