Un opérateur est un symbole qui indique au compilateur d'effectuer une opération mathématique ou logique spécifique, telle que : 3+2=5.
Le langage Perl possède une multitude d’opérateurs intégrés. Jetons un coup d’œil à ceux couramment utilisés :
opérateurs arithmétiques
opérateur de comparaison
Opérateurs logiques
opérateur d'affectation
Opérateurs de bits
opérateur de devis
Autres opérateurs
priorité des opérateurs
Dans l'exemple de tableau, nous définissons les variables $a sur 10 et $b sur 20.
| opérateur | décrire | Exemple |
|---|---|---|
| + | Ajout | $a + $b donne 30 |
| - | opération de soustraction | $a - $b donne -10 |
| * | Multiplication | $a * $b donne 200 |
| / | Opération de division | $b / $a donne 2 |
| % | Rechercher l'opération de reste, reste après division entière | $b % $a donne 0 |
| ** | Multiplier par la puissance | Le résultat de $a**$b est 10 élevé à la puissance 20 |
Le résultat de l’exécution du programme ci-dessus est :
$a = 10 , $b = 20$a + $b = 30$a - $b = -10$a * $b = 200$a / $b = 0,5$a % $b = 10$a ** $ b = 16
Dans l'exemple de tableau, nous définissons les variables $a sur 10 et $b sur 20.
| opérateur | décrire | Exemple |
|---|---|---|
| == | Vérifie si les valeurs de deux opérandes sont égales, si elles sont égales alors la condition est vraie, sinon elle est fausse. | ($a == $b) est faux |
| != | Vérifie si les valeurs des deux opérandes sont égales, sinon la condition est vraie, sinon elle est fausse. | ($a != $b) est vrai. |
| <=> | Vérifie si les valeurs des deux opérandes sont égales, en renvoyant -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 sur la 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 alors la condition est vraie, sinon elle est fausse. | ($a > $b) renvoie faux. |
| < | Vérifie si la valeur de l'opérande de gauche est inférieure à la valeur de l'opérande de droite, si c'est le cas alors la condition est vraie, sinon elle renvoie faux. | ($a < $b) renvoie vrai. |
| >= | Vérifie si la valeur de l'opérande de gauche est supérieure ou égale à la valeur de l'opérande de droite, si c'est le cas alors la condition est vraie, sinon elle renvoie faux. | ($a >= $b) renvoie faux. |
| <= | Vérifie si la valeur de l'opérande de gauche est inférieure ou égale à la valeur de l'opérande de droite, si c'est le cas alors la condition est vraie, sinon elle renvoie faux. . | ($a <= $b) renvoie vrai. |
Le résultat de l’exécution du programme ci-dessus est :
$a = 10 , $b = 20$a == $b Le résultat est faux$a != $b Le résultat est vrai$a <=> $b Retour -1$a > $b Le résultat est faux$a >= $b Le résultat est faux $a < $b résultats vrai$a <= $b résultats vrai
Dans l'exemple de tableau suivant, définissez la variable $a sur « abc » et $b sur « xyz », puis utilisez des opérateurs de comparaison pour calculer le résultat.
| opérateur | décrire | Exemple |
|---|---|---|
| lt | Vérifie si la chaîne de gauche est plus petite que la chaîne de droite, si c'est le cas, elle renvoie vrai, sinon elle renvoie faux. | ($a lt $b) renvoie vrai. |
| GT | Vérifie si la chaîne de gauche est supérieure à la chaîne de droite, si c'est le cas, elle renvoie vrai, sinon elle renvoie faux. | ($a gt $b) renvoie faux. |
| le | Vérifie si la chaîne de gauche est inférieure ou égale à la chaîne de droite, si c'est le cas, elle renvoie vrai, sinon elle renvoie faux. | ($a le $b) renvoie vrai |
| ge | Vérifie si la chaîne de gauche est supérieure ou égale à la chaîne de droite, si c'est le cas, elle renvoie vrai, sinon elle renvoie faux. | ($a ge $b) renvoie faux. |
| équip | Vérifie si la chaîne de gauche est égale à la chaîne de droite, si c'est le cas, elle renvoie vrai, sinon elle renvoie faux. | ($a eq $b) renvoie faux. |
| ne | Vérifie si la chaîne de gauche n'est pas égale à la chaîne de droite, si c'est le cas, elle renvoie vrai, sinon elle renvoie faux. | ($a ne $b) renvoie vrai |
| cmp | Renvoie 1 si la chaîne de gauche est supérieure à la chaîne de droite, 0 si égale et -1 si la chaîne de gauche est inférieure à la chaîne de droite. | ($a cmp $b) renvoie -1. |
Le résultat de l’exécution du programme ci-dessus est :
$a = abc, $b = xyzabc lt $b renvoie vrai$a gt $b renvoie faux$a le $b renvoie vrai$a ge $b renvoie faux$a ne $b renvoie vrai$a cmp $b renvoie -1
Dans l'exemple de tableau, nous définissons les variables $a sur 10 et $b sur 20.
| opérateur | décrire | Exemple |
|---|---|---|
| = | Opérateur d'affectation simple, attribue la valeur de l'opérande de droite à l'opérande de gauche | $c = $a + $b attribuera la valeur de $a + $b à $c |
| += | L'opérateur d'addition et d'affectation attribue le résultat de l'ajout de l'opérande droit à l'opérande gauche à l'opérande gauche. | $c += $a est égal à $c = $c + $a |
| -= | L'opérateur de soustraction ET d'affectation attribue le résultat de la soustraction de l'opérande droit de l'opérande gauche à l'opérande gauche. | $c -= $a est égal à $c = $c - $a |
| *= | L'opérateur de multiplication et d'affectation attribue le résultat de la multiplication de l'opérande droit par l'opérande gauche à l'opérande gauche. | $c *= $a est égal à $c = $c * $a |
| /= | L'opérateur de division et d'affectation attribue le résultat de la division de l'opérande de gauche par l'opérande de droite à l'opérande de gauche. | $c /= $a est égal à $c = $c / $a |
| %= | Opérateur de module et d'affectation, trouve le module de deux opérandes et l'affecte à l'opérande de gauche | $c %= $a est équivalent à $c = $c % a |
| **= | L'opérateur d'exponentiation et d'affectation trouve la puissance des deux opérandes et les affecte à l'opérande de gauche. | $c **= $a est égal à $c = $c ** $a |
Le résultat de l’exécution du programme ci-dessus est :
$a = 10, $b = 20. Après affectation, $c = 30$c = 40, instruction d'opération $c += $a$c = 30, instruction d'opération $c -= $a$c = 300, instruction d'opération $c *= $a$c = 30, instruction d'opération $c /= $a$c = 0, instruction d'opération $c %= $a$a = 4, $c = 2$c = 16, instruction d'opération $c **= $a
Les opérateurs au niveau bit opèrent sur des bits et effectuent des opérations petit à petit.
En définissant $a = 60, $b = 13, maintenant au format binaire, ils ressemblent à ceci :
$a = 0011 1100$b = 0000 1101----------------$a&$b = 0000 1100$a|$b = 0011 1101$a^$b = 0011 0001 ~$a = 1100 0011
Les opérateurs au niveau du bit pris en charge par Perl sont présentés dans le tableau suivant :
| opérateur | décrire | Exemple |
|---|---|---|
| & | L'opérateur binaire AND copie un bit dans le résultat si les deux opérandes sont présents. | ($a & $b) vous donnera 12, ce qui en binaire est 0000 1100 |
| | | L'opérateur binaire OU copie un bit dans le résultat s'il est présent dans l'un ou l'autre des opérandes. | ($a | $b) obtiendra 61, soit 0011 1101 en binaire |
| ^ | L'opérateur binaire XOR copie un bit dans le résultat s'il est présent dans l'un des opérandes mais pas dans les deux. | ($a ^ $b) vous donnera 49, ce qui en binaire est 0011 0001 |
| ~ | L'opérateur complément binaire est un opérateur unaire qui a pour effet de « retourner » les bits, c'est-à-dire que 0 devient 1 et 1 devient 0. | (~$a ) donnera -61, qui est 1100 0011 en binaire, la forme complémentaire à un d'un nombre binaire signé. |
| << | Opérateur de décalage binaire vers la gauche. La valeur de l'opérande de gauche est décalée vers la gauche du nombre de bits spécifié par l'opérande de droite. | $a << 2 vous donnera 240, soit 1111 0000 en binaire |
| >> | Opérateur de décalage binaire vers la droite. La valeur de l'opérande de gauche est décalée vers la droite du nombre de bits spécifié par l'opérande de droite. | $a >> 2 obtiendra 15, ce qui en binaire est 0000 1111 |
Le résultat de l’exécution 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
Les opérateurs logiques Perl sont présentés dans le tableau suivant.
Dans l'exemple de tableau, nous définissons la variable $a sur true et $b sur false.
| opérateur | décrire | Exemple |
|---|---|---|
| et | Opérateur ET logique. Si les deux opérandes sont vrais, la condition est vraie. | ($a et $b) est faux. |
| && | Opérateur ET logique de style C. La condition est vraie si les deux opérandes sont vrais | ($a && $b) est faux. |
| ou | Opérateur OU logique. La condition est vraie si l’un des deux opérandes est différent de zéro. | ($a ou $b) est vrai. |
| || | Opérateur OU logique de style C. La condition est vraie si l’un des deux opérandes est différent de zéro. | ($a || $b) est vrai. |
| pas | Opérateur NON logique. Utilisé pour inverser l'état logique de l'opérande. Si la condition est vraie, l’opérateur logique NOT la rendra fausse. | not($a et $b) est vrai. |
Le résultat de l’exécution du programme ci-dessus est :
$a = true , $b = false$a et $b = false$a && $b = false$a ou $b = true$a ||
Les opérateurs de cotation Perl sont présentés dans le tableau suivant.
| opérateur | décrire | Exemple |
|---|---|---|
| q{ } | Ajouter des guillemets simples à la chaîne | q{abcd} donne 'abcd' |
| qq{ } | Ajouter des guillemets doubles à la chaîne | qq{abcd} donne "abcd" |
| qx{ } | Ajouter des backticks à la chaîne | qx{abcd} donne `abcd` |
Le résultat de l’exécution du programme ci-dessus est :
q{a = $a} = a = $aqq{a = $a} = a = 10qx{date} = vendredi 10 juin 2016 16:22:33 CSTEn plus des opérateurs mentionnés ci-dessus, Perl prend également en charge les opérateurs suivants :
| opérateur | décrire | Exemple |
|---|---|---|
| . | Le point (.) est utilisé pour concaténer deux chaînes. | Si $a="run", $b="oob" , le résultat de $a.$b est "codercto" |
| x | L'opérateur x renvoie le nombre de fois qu'une chaîne est répétée. | ('-' x 3) La sortie est ---. |
| .. | .. est l'opérateur de plage. | (2..5) Le résultat de sortie est (2, 3, 4, 5) |
| ++ | Opérateur d'incrémentation, la valeur entière augmente de 1 | $a =10, $a++ affichera 11 |
| -- | Opérateur de décrémentation, décrémente une valeur entière de 1 | $a =10, $a-- la sortie est 9 |
| -> | Les flèches sont utilisées pour spécifier les méthodes d'une classe | $obj->$a représente la méthode $a de l'objet $obj. |
Le résultat de l’exécution du programme ci-dessus est :
$a = exécuter, $b = oob$a . $b = codercto"-" x 3 = ---(2..5) = 2 3 4 5$a = 10 , $b = 15$a exécuter $a++. = 11$b exécuter $b-- = 14
Le tableau suivant répertorie la priorité des opérateurs du langage Perl :
| opérateur | associativité |
|---|---|
| ++, -- | aucun |
| -, ~, ! | de droite à gauche |
| ** | de droite à gauche |
| =~, !~ | de gauche à droite |
| *, /, %, x | de gauche à droite |
| +, -, . | de gauche à droite |
| <<, >> | de gauche à droite |
| -e, -r, | aucun |
| <, <=, >, >=, 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 |
| ? et : | de droite à gauche |
| =, +=, -=, *=, | de droite à gauche |
| autre | |
| , | de gauche à droite |
| pas | de gauche à droite |
| et | de gauche à droite |
| ou, xor | de gauche à droite |
Le résultat de l’exécution 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 = 50