Opérateurs Perl
Les opérateurs sont des symboles qui indiquent au compilateur d'effectuer des opérations mathématiques ou logiques spécifiques, telles que : 3+2=5.
Le langage Perl dispose d'un riche ensemble d'opérateurs intégrés. Examinons les plus couramment utilisés :
- Opérateurs arithmétiques
- Opérateurs de comparaison
- Opérateurs logiques
- Opérateurs d'affectation
- Opérateurs bit à bit
- Opérateurs de citation
- Autres opérateurs
- Précédence des opérateurs
Opérateurs arithmétiques
Dans les exemples du tableau suivant, nous définissons la variable $a à 10 et $b à 20.
| Operator | Description | Exemple |
|---|---|---|
| + | Opération d'addition | Le résultat de $a + $b est 30 |
| - | Opération de soustraction | Le résultat de $a - $b est -10 |
| * | Opération de multiplication | Le résultat de $a * $b est 200 |
| / | Opération de division | Le résultat de $b / $a est 2 |
| % | Opération modulo, reste après division | Le résultat de $b % $a est 0 |
| ** | Exponentiation | Le résultat de $a**$b est 10 à la puissance 20 |
Exemple
#!/usr/bin/perl
$a = 10;
$b = 20;
print "\$a = $a , \$b = $b\n";
$c = $a + $b;
print '$a + $b = ' . $c . "\n";
$c = $a - $b;
print '$a - $b = ' . $c . "\n";
$c = $a * $b;
print '$a * $b = ' . $c . "\n";
$c = $a / $b;
print '$a / $b = ' . $c . "\n";
$c = $a % $b;
print '$a % $b = ' . $c. "\n";
$a = 2;
$b = 4;
$c = $a ** $b;
print '$a ** $b = ' . $c . "\n";
L'exécution du programme ci-dessus produit la sortie suivante :
$a = 10 , $b = 20 $a + $b = 30 $a - $b = -10 $a * $b = 200 $a / $b = 0.5 $a % $b = 10 $a ** $b = 16
Opérateurs de comparaison
Dans les exemples du tableau suivant, nous définissons la variable $a à 10 et $b à 20.
| Operator | Description | Exemple |
|---|---|---|
| == | Vérifie si les valeurs de deux opérandes sont égales. Si elles sont égales, la condition est vraie, sinon fausse. | ($a == $b) est faux |
| != | Vérifie si les valeurs de deux opérandes sont égales. Si elles ne sont pas égales, la condition est vraie, sinon fausse. | ($a != $b) est vrai. |
| <=> | Vérifie si les valeurs de deux opérandes sont égales. Renvoie -1 si le nombre de gauche est inférieur au nombre de droite, 0 s'ils sont égaux, et 1 si le nombre de gauche est supérieur au nombre de droite. | ($a <=> $b) renvoie -1. |
| > | Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit. Si c'est le cas, la condition est vraie, sinon fausse. | ($a > $b) renvoie faux. |
| < | Vérifie si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande droit. Si c'est le cas, la condition est vraie, sinon renvoie faux. | ($a < $b) renvoie vrai. |
| >= | Vérifie si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit. Si c'est le cas, la condition est vraie, sinon renvoie faux. | ($a >= $b) renvoie false. |
| <= | Vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de l'opérande droit. Si c'est le cas, la condition est vraie, sinon renvoie false. | ($a <= $b) renvoie true. |
Exemple
#!/usr/bin/perl
$a = 10;
$b = 20;
print "\$a = $a , \$b = $b\n";
if( $a == $b ){
print "$a == \$b résultat true\n";
}else{
print "\$a == \$b résultat false\n";
}
if( $a != $b ){
print "\$a != \$b résultat true\n";
}else{
print "\$a != \$b résultat false\n";
}
$c = $a <=> $b;
print "\$a <=> \$b renvoie$c\n";
if( $a > $b ){
print "\$a > \$b résultat true\n";
}else{
print "\$a > \$b résultat false\n";
}
if( $a >= $b ){
print "\$a >= \$b résultat true\n";
}else{
print "\$a >= \$b résultat false\n";
}
if( $a < $b ){
print "\$a < \$b résultat true\n";
}else{
print "\$a < \$b résultat false\n";
}
if( $a <= $b ){
print "\$a <= \$b résultat true\n";
}else{
print "\$a <= \$b résultat false\n";
}
L'exécution du programme ci-dessus produit la sortie suivante :
$a = 10 , $b = 20 $a == $b 结果 false $a != $b 结果 true $a <=> $b 返回 -1 $a > $b 结果 false $a >= $b 结果 false $a < $b 结果 true $a <= $b 结果 true
Dans les exemples du tableau suivant, nous affectons la valeur "abc" à la variable $a et la valeur "xyz" à $b, puis utilisons des opérateurs de comparaison pour calculer les résultats.
| Operator | Description | Exemple |
|---|---|---|
| lt | Vérifie si la chaîne de gauche est inférieure à la chaîne de droite. Si c'est le cas, renvoie true, sinon renvoie false. | ($a lt $b) renvoie true. |
| gt | Vérifie si la chaîne de gauche est supérieure à la chaîne de droite. Si c'est le cas, renvoie true, sinon renvoie false. | ($a gt $b) renvoie false. |
| le | Vérifie si la chaîne de gauche est inférieure ou égale à la chaîne de droite. Si c'est le cas, renvoie true, sinon renvoie false. | ($a le $b) renvoie true |
| ge | Vérifie si la chaîne de gauche est supérieure ou égale à la chaîne de droite. Si c'est le cas, renvoie true, sinon renvoie false. | ($a ge $b) renvoie false. |
| eq | Vérifie si la chaîne de gauche est égale à la chaîne de droite. Si c'est le cas, renvoie true, sinon renvoie false. | ($a eq $b) renvoie false. |
| ne | Vérifie si la chaîne de gauche est différente de la chaîne de droite. Si c'est le cas, renvoie true, sinon renvoie false. | ($a ne $b) renvoie true |
| cmp | Renvoie 1 si la chaîne de gauche est supérieure à la chaîne de droite, renvoie 0 si elles sont égales, et renvoie -1 si la chaîne de gauche est inférieure à la chaîne de droite. | ($a cmp $b) renvoie -1. |
Exemple
#!/usr/bin/perl
$a = "abc";
$b = "xyz";
print "\$a = $a ，\$b = $b\n";
if( $a lt $b ){
print "$a lt \$b renvoie vrai\n";
}else{
print "\$a lt \$b renvoie faux\n";
}
if( $a gt $b ){
print "\$a gt \$b renvoie vrai\n";
}else{
print "\$a gt \$b renvoie faux\n";
}
if( $a le $b ){
print "\$a le \$b renvoie vrai\n";
}else{
print "\$a le \$b renvoie faux\n";
}
if( $a ge $b ){
print "\$a ge \$b renvoie vrai\n";
}else{
print "\$a ge \$b renvoie faux\n";
}
if( $a ne $b ){
print "\$a ne \$b renvoie vrai\n";
}else{
print "\$a ne \$b renvoie false\n";
}
$c = $a cmp $b;
print "\$a cmp \$b renvoie$c\n";
L'exécution du programme ci-dessus produit la sortie suivante :
$a = abc ，$b = xyz abc lt $b 返回 true $a gt $b 返回 false $a le $b 返回 true $a ge $b 返回 false $a ne $b 返回 true $a cmp $b 返回 -1
Opérateurs d'affectation
Dans les exemples du tableau suivant, nous définissons la variable $a à 10 et $b à 20.
| Operator | Description | Exemple |
|---|---|---|
| = | Opérateur d'affectation simple, affecte la valeur de l'opérande de droite à l'opérande de gauche | $c = $a + $b affectera la valeur de $a + $b à $c |
| += | Opérateur d'addition et d'affectation, affecte à l'opérande de gauche le résultat de l'addition de l'opérande de droite à l'opérande de gauche | $c += $a est équivalent à $c = $c + $a |
| -= | Opérateur de soustraction et d'affectation, affecte à l'opérande de gauche le résultat de la soustraction de l'opérande de droite à l'opérande de gauche | $c -= $a est équivalent à $c = $c - $a |
| *= | Opérateur de multiplication et d'affectation, affecte à l'opérande de gauche le résultat de la multiplication de l'opérande de droite par l'opérande de gauche | $c *= $a est équivalent à $c = $c * $a |
| /= | Opérateur de division et d'affectation, affecte à l'opérande de gauche le résultat de la division de l'opérande de gauche par l'opérande de droite | $c /= $a est équivalent à $c = $c / $a |
| %= | Opérateur de modulo et d'affectation, prend le modulo des deux opérandes et l'affecte à l'opérande de gauche | $c %= $a est équivalent à $c = $c % a |
| **= | Opérateur d'exponentiation et d'affectation, calcule la puissance des deux opérandes et l'affecte à l'opérande de gauche | $c **= $a est équivalent à $c = $c ** $a |
Exemple
#!/usr/bin/perl
$a = 10;
$b = 20;
print "\$a = $a ，\$b = $b\n";
$c = $a + $b;
print "Après affectation\$c = $c\n";
$c += $a;
print "\$c = $c, instruction d'opération\$c += \$a\n";
$c -= $a;
print "\$c = $c, instruction d'opération\$c -= \$a\n";
$c *= $a;
print "\$c = $c, instruction d'opération\$c *= \$a\n";
$c /= $a;
print "\$c = $c , instruction d'opération \$c/= \$a\n";
$c %= $a;
print "\$c = $c, instruction d'opération \$c %= \$a\n";
$c = 2;
$a = 4;
print "\$a = $a ， \$c = $c\n";
$c **= $a;
print "\$c = $c, instruction d'opération \$c **= \$a\n";
L'exécution du programme ci-dessus produit la sortie suivante :
$a = 10 ，$b = 20 赋值后 $c = 30 $c = 40 ，运算语句 $c += $a $c = 30 ，运算语句 $c -= $a $c = 300 ，运算语句 $c *= $a $c = 30 ，运算语句 $c /= $a $c = 0 ，运算语句 $c %= $a $a = 4 ， $c = 2 $c = 16 ，运算语句 $c **= $a
Opérations bit à bit
Les opérateurs bit à bit agissent sur les bits et effectuent des opérations bit par bit.
Définissez $a = 60, $b = 13. Maintenant, représentés au format binaire, ils sont les suivants :
$a = 0011 1100 $b = 0000 1101 ----------------- $a&$b = 0000 1100 $a|$b = 0011 1101 $a^$b = 0011 0001 ~$a = 1100 0011
Les opérateurs bit à bit pris en charge par Perl sont présentés dans le tableau suivant :
| Operator | Description | Exemple |
|---|---|---|
| & | Si présent dans les deux opérandes, l'opérateur AND binaire copie un bit dans le résultat. | ($a & $b) donnera 12, soit 0000 1100 en binaire |
| | | Si présent dans l'un ou l'autre des opérandes, l'opérateur OR binaire copie un bit dans le résultat. | ($a | $b) donnera 61, en binaire 0011 1101 |
| ^ | L'opérateur XOR binaire copie un bit dans le résultat s'il existe dans l'un ou l'autre des opérandes, mais pas dans les deux. | ($a ^ $b) donnera 49, en binaire 0011 0001 |
| ~ | L'opérateur de complément à un binaire est un opérateur unaire, ayant pour effet d'« inverser » les bits, c'est-à-dire que 0 devient 1 et 1 devient 0. | (~$a ) donnera -61, en binaire 1100 0011, la forme en complément à un d'un nombre binaire signé. |
| << | Opérateur binaire de décalage à gauche. La valeur de l'opérande gauche est décalée vers la gauche du nombre de bits spécifié par l'opérande droit. | $a << 2 donnera 240, en binaire 1111 0000 |
| >> | Opérateur binaire de décalage à droite. La valeur de l'opérande gauche est décalée vers la droite du nombre de bits spécifié par l'opérande droit. | $a >> 2 donnera 15, en binaire 0000 1111 |
Exemple
#!/usr/bin/perl
use integer;
$a = 60;
$b = 13;
print "\$a = $a , \$b = $b\n";
$c = $a & $b;
print "\$a & \$b = $c\n";
$c = $a | $b;
print "\$a | \$b = $c\n";
$c = $a ^ $b;
print "\$a ^ \$b = $c\n";
$c = ~$a;
print "~\$a = $c\n";
$c = $a << 2;
print "\$a << 2 = $c\n";
$c = $a >> 2;
print "\$a >> 2 = $c\n";
La sortie du programme ci-dessus est :
$a = 60 , $b = 13 $a & $b = 12 $a | $b = 61 $a ^ $b = 49 ~$a = -61 $a << 2 = 240 $a >> 2 = 15
Opérateurs logiques
Les opérateurs logiques Perl sont présentés dans le tableau suivant.
Dans les exemples du tableau, nous définissons la variable $a sur vrai, $b sur faux.
| Operator | Description | Exemple |
|---|---|---|
| et | Opérateur ET logique. Si les deux opérandes sont vrais, la condition est vraie. | ($a and $b) est faux. |
| && | Opérateur ET logique de style C. Si les deux opérandes sont vrais, la condition est vraie. | ($a && $b) est faux. |
| ou | Opérateur OU logique. Si l'un des opérandes est non nul, la condition est vraie. | ($a or $b) est vrai. |
| || | Opérateur OU logique de style C. Si l'un des opérandes est non nul, la condition est vraie. | ($a || $b) est vrai. |
| not | Opérateur NON logique. Utilisé pour inverser l'état logique de l'opérande. Si la condition est vraie, l'opérateur NON logique la rendra fausse. | not($a and $b) est vrai. |
Exemple
#!/usr/bin/perl
$a = true;
$b = false;
print "\$a = $a , \$b = $b\n";
$c = ($a and $b);
print "\$a and \$b = $c\n";
$c = ($a && $b);
print "\$a && \$b = $c\n";
$c = ($a or $b);
print "\$a or \$b = $c\n";
$c = ($a || $b);
print "\$a || \$b = $c\n";
$a = 0;
$c = not($a);
print "not(\$a)= $c\n";
La sortie du programme ci-dessus est :
$a = true , $b = false $a and $b = false $a && $b = false $a or $b = true $a || $b = true not($a)= 1
Opérations de citation
Les opérateurs de citation Perl sont indiqués dans le tableau suivant.
| Operator | Description | Exemple |
|---|---|---|
| q{ } | Ajoute des guillemets simples autour d'une chaîne | q{abcd} donne 'abcd' |
| qq{ } | Ajoute des guillemets doubles autour d'une chaîne | qq{abcd} donne "abcd" |
| qx{ } | Ajoute des accents graves autour d'une chaîne | qx{abcd} donne `abcd` |
Exemple
#!/usr/bin/perl
$a = 10;
$b = q{a = $a};
print "q{a = \$a} = $b\n";
$b = qq{a = $a};
print "qq{a = \$a} = $b\n";
# Exécuter à l'aide de la commande unix date
$t = qx{date};
print "qx{date} = $t\n";
La sortie du programme ci-dessus est :
q{a = $a} = a = $a
qq{a = $a} = a = 10
qx{date} = 2016年 6月10日 星期五 16时22分33秒 CST
Autres opérateurs
En plus des opérateurs mentionnés ci-dessus, Perl prend également en charge les opérateurs suivants :
| Operator | Description | Exemple |
|---|---|---|
| . | Le point (.) est utilisé pour concaténer deux chaînes. | Si $a="run", $b="oob", alors $a.$b donne "example" |
| x | L'opérateur x renvoie la chaîne répétée un nombre spécifié de fois. | ('-' x 3) produit ---. |
| .. | .. est l'opérateur d'intervalle. | (2..5) produit (2, 3, 4, 5) |
| ++ | Opérateur d'incrémentation, augmente la valeur entière de 1 | $a =10, $a++ produit 11 |
| -- | Opérateur de décrémentation, diminue la valeur entière de 1 | $a =10, $a-- produit 9 |
| -> | La flèche est utilisée pour spécifier une méthode d'une classe | $obj->$a représente la méthode $a de l'objet $obj. |
Exemple
#!/usr/bin/perl
$a = "run";
$b = "oob";
print "\$a = $a ， \$b = $b\n";
$c = $a . $b;
print "\$a . \$b = $c\n";
$c = "-" x 3;
print "\"-\" x 3 = $c\n";
@c = (2..5);
print "(2..5) = @c\n";
$a = 10;
$b = 15;
print "\$a = $a ， \$b = $b\n";
$a++;
$c = $a ;
print "\$a exécute\$a++ = $c\n";
$b--;
$c = $b ;
print "\$b exécute\$b-- = $c\n";
La sortie du programme ci-dessus est :
$a = run ， $b = oob $a . $b = example "-" x 3 = --- (2..5) = 2 3 4 5 $a = 10 ， $b = 15 $a 执行 $a++ = 11 $b 执行 $b-- = 14
Précédence des opérateurs
Le tableau suivant répertorie la priorité des opérateurs du langage Perl :
| Operator | Associativité |
|---|---|
| ++, -- | Aucune |
| -, ~, ! | De droite à gauche |
| ** | De droite à gauche |
| =~, !~ | De gauche à droite |
| *, /, %, x | De gauche à droite |
| +, -, . | De gauche à droite |
| <<, >> | De gauche à droite |
| -e, -r, | Aucune |
| <, <=, >, >=, lt, le, gt, ge | De gauche à droite |
| ==, !=, <=>, eq, ne, cmp | De gauche à droite |
| & | De gauche à droite |
| |, ^ | De gauche à droite |
| && | De gauche à droite |
| || | De gauche à droite |
| .. | De gauche à droite |
| ? and : | De droite à gauche |
| =, +=, -=, *=, | De droite à gauche |
| Autre | |
| , | De gauche à droite |
| not | De gauche à droite |
| et | De gauche à droite |
| or, xor | De gauche à droite |
Exemple
#!/usr/bin/perl
$a = 20;
$b = 10;
$c = 15;
$d = 5;
$e;
print "\$a = $a, \$b = $b, \$c = $c ，\$d = $d\n";
$e = ($a + $b) * $c / $d;
print "(\$a + \$b) * \$c / \$d = $e\n";
$e = (($a + $b) * $c )/ $d;
print "((\$a + \$b) * \$c) / \$d = $e\n";
$e = ($a + $b) * ($c / $d);
print "(\$a + \$b) * (\$c / \$d ) = $e\n";
$e = $a + ($b * $c ) / $d;
print "\$a + (\$b * \$c )/ \$d = $e\n";
La sortie du programme ci-dessus est :
$a = 20, $b = 10, $c = 15 ，$d = 5 ($a + $b) * $c / $d = 90 (($a + $b) * $c) / $d = 90 ($a + $b) * ($c / $d ) = 90 $a + ($b * $c )/ $d = 50Autres extensions