Opérateurs Scala
Un opérateur est un symbole qui indique au compilateur d'effectuer des opérations mathématiques et logiques spécifiées.
Scala dispose de nombreux opérateurs intégrés, notamment les types suivants :
Opérateurs arithmétiques
Opérateurs relationnels
Opérateurs logiques
Opérateurs bit à bit
Opérateurs d'affectation
Ensuite, nous présenterons en détail les applications des opérateurs ci-dessus.
Opérateurs arithmétiques
Le tableau suivant répertorie les opérateurs arithmétiques pris en charge par Scala.
Supposons que la variable A soit 10 et que B soit 20 :
| Operator | Description | Exemple |
|---|---|---|
| + | Plus | A + B vaut 30 |
| - | Moins | A - B s'évalue à -10 |
| * | Multiplication | A * B s'évalue à 200 |
| / | Division | B / A s'évalue à 2 |
| % | Modulo | B % A s'évalue à 0 |
Exemple
Exemple
def main(args: Array[String]) = {
var a = 10;
var b = 20;
var c = 25;
var d = 25;
println("a + b = " + (a + b) );
println("a - b = " + (a - b) );
println("a * b = " + (a * b) );
println("b / a = " + (b / a) );
println("b % a = " + (b % a) );
println("c % a = " + (c % a) );
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test a + b = 30 a - b = -10 a * b = 200 b / a = 2 b % a = 0 c % a = 5
Opérateurs relationnels
Le tableau suivant liste les opérateurs relationnels pris en charge par Scala.
Supposons que la variable A soit 10 et que B soit 20 :
| Operator | Description | Exemple |
|---|---|---|
| == | Égal à | (A == B) s'évalue à false |
| != | Différent de | (A != B) s'évalue à true |
| > | Supérieur à | (A > B) s'évalue à false |
| < | Inférieur à | (A < B) s'évalue à true |
| >= | Supérieur ou égal à | (A >= B) s'évalue à false |
| <= | Inférieur ou égal à | (A <= B) s'évalue à true |
Exemple
Exemple
def main(args: Array[String]) = {
var a = 10;
var b = 20;
println("a == b = " + (a == b) );
println("a != b = " + (a != b) );
println("a > b = " + (a > b) );
println("a < b = " + (a < b) );
println("b >= a = " + (b >= a) );
println("b <= a = " + (b <= a) );
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test a == b = false a != b = true a > b = false a < b = true b >= a = true b <= a = false
Opérateurs logiques
Le tableau suivant répertorie les opérateurs logiques pris en charge par Scala.
Supposons que la variable A vaut 1 et B vaut 0 :
| Operator | Description | Exemple |
|---|---|---|
| && | ET logique | (A && B) s'évalue à false |
| || | OU logique | (A || B) s'évalue à true |
| ! | NON logique | !(A && B) s'évalue à true |
Exemple
Exemple
def main(args: Array[String]) = {
var a = true;
var b = false;
println("a && b = " + (a&&b) );
println("a || b = " + (a||b) );
println("!(a && b) = " + !(a && b) );
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test a && b = false a || b = true !(a && b) = true
Opérateurs bit à bit
Les opérateurs bit à bit sont utilisés pour opérer sur des bits binaires,~,&,|,^à savoir les opérations NOT, AND, OR et XOR bit à bit, comme montré dans les exemples du tableau suivant :
| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
Si A = 60 ; et B = 13 ; les représentations binaires des deux variables sont :
A = 0011 1100 B = 0000 1101 -------位运算---------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001 ~A = 1100 0011
Les règles des opérations bit à bit en Scala sont les suivantes :
| Operator | Description | Exemple |
|---|---|---|
| & | Opérateur AND bit à bit | (a & b) renvoie 12, explication binaire : 0000 1100 |
| | | Opérateur OR bit à bit | (a | b) renvoie 61, explication binaire : 0011 1101 |
| ^ | Opérateur XOR bit à bit | (a ^ b) renvoie 49, explication binaire : 0011 0001 |
| ~ | Opérateur NOT bit à bit | (~a) donne -61, explication binaire : 1100 0011, sous la forme en complément à deux d'un nombre binaire signé. |
| << | Opérateur de décalage à gauche | a << 2 donne 240, explication binaire : 1111 0000 |
| >> | Opérateur de décalage à droite | a >> 2 donne 15, explication binaire : 0000 1111 |
| >>> | Décalage à droite non signé | A >>> 2 donne 15, explication binaire : 0000 1111 |
Exemple
Exemple
def main(args: Array[String]) = {
var a = 60; /* 60 = 0011 1100 */
var b = 13; /* 13 = 0000 1101 */
var c = 0;
c = a & b; /* 12 = 0000 1100 */
println("a & b = " + c );
c = a | b; /* 61 = 0011 1101 */
println("a | b = " + c );
c = a ^ b; /* 49 = 0011 0001 */
println("a ^ b = " + c );
c = ~a; /* -61 = 1100 0011 */
println("~a = " + c );
c = a << 2; /* 240 = 1111 0000 */
println("a << 2 = " + c );
c = a >> 2; /* 15 = 1111 */
println("a >> 2 = " + c );
c = a >>> 2; /* 15 = 0000 1111 */
println("a >>> 2 = " + c );
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test a & b = 12 a | b = 61 a ^ b = 49 ~a = -61 a << 2 = 240 a >> 2 = 15 a >>> 2 = 15
Opérateurs d'affectation
Ce qui suit répertorie les opérateurs d'affectation pris en charge par le langage Scala :
| Operator | Description | Exemple |
|---|---|---|
| = | Affectation simple, affecte la valeur de l'opérande droit à l'opérande gauche. | C = A + B affecte le résultat de A + B à C |
| += | Addition et affectation, additionne les opérandes gauche et droit, puis affecte le résultat à l'opérande gauche. | C += A équivaut à C = C + A |
| -= | Soustraction et affectation, soustrait l'opérande droit de l'opérande gauche, puis affecte le résultat à l'opérande gauche. | C -= A est équivalent à C = C - A |
| *= | Multiplier et assigner, multiplie les opérandes gauche et droite puis affecte le résultat à l'opérande gauche. | C *= A est équivalent à C = C * A |
| /= | Diviser et assigner, divise l'opérande gauche par l'opérande droit puis affecte le résultat à l'opérande gauche. | C /= A est équivalent à C = C / A |
| %= | Modulo et assigner, prend le reste de la division de l'opérande gauche par l'opérande droit et l'affecte à l'opérande gauche. | C %= A est équivalent à C = C % A |
| <<= | Décalage à gauche bit à bit et affectation | C <<= 2 est équivalent à C = C << 2 |
| >>= | Décalage à droite bit à bit et affectation | C >>= 2 est équivalent à C = C >> 2 |
| &= | ET bit à bit et affectation | C &= 2 est équivalent à C = C & 2 |
| ^= | OU exclusif bit à bit et affectation | C ^= 2 est équivalent à C = C ^ 2 |
| |= | OU bit à bit et affectation | C |= 2 est équivalent à C = C | 2 |
Exemple
Exemple
def main(args: Array[String]) = {
var a = 10;
var b = 20;
var c = 0;
c = a + b;
println("c = a + b = " + c );
c += a ;
println("c += a = " + c );
c -= a ;
println("c -= a = " + c );
c *= a ;
println("c *= a = " + c );
a = 10;
c = 15;
c /= a ;
println("c /= a = " + c );
a = 10;
c = 15;
c %= a ;
println("c %= a = " + c );
c <<= 2 ;
println("c <<= 2 = " + c );
c >>= 2 ;
println("c >>= 2 = " + c );
c >>= a ;
println("c >>= a = " + c );
c &= a ;
println("c &= 2 = " + c );
c ^= a ;
println("c ^= a = " + c );
c |= a ;
println("c |= a = " + c );
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test c = a + b = 30 c += a = 40 c -= a = 30 c *= a = 300 c /= a = 1 c %= a = 5 c <<= 2 = 20 c >>= 2 = 5 c >>= a = 0 c &= 2 = 0 c ^= a = 10 c |= a = 10
La priorité des opérateurs dépend du groupe d'opérateurs auquel appartient l'opérateur, et elle affecte l'évaluation d'une expression.
Exemple : x = 7 + 3 * 2; ici, x est évalué à 13, pas 20, car la multiplication (*) a une priorité supérieure à l'addition (+), donc il calcule d'abord 3*2 puis ajoute 7.
Reportez-vous au tableau suivant. La priorité diminue du haut vers le bas ; le haut a la priorité la plus élevée, et l'opérateur virgule a la priorité la plus faible.
| Catégorie | Operator | Associativité |
|---|---|---|
| 1 | () [] | De gauche à droite |
| 2 | ! ~ | De droite à gauche |
| 3 | * / % | De gauche à droite |
| 4 | + - | De gauche à droite |
| 5 | >> >>> << | De gauche à droite |
| 6 | > >= < <= | De gauche à droite |
| 7 | == != | De gauche à droite |
| 8 | & | De gauche à droite |
| 9 | ^ | De gauche à droite |
| 10 | | | De gauche à droite |
| 11 | && | De gauche à droite |
| 12 | || | De gauche à droite |
| 13 | = += -= *= /= %= >>= <<= &= ^= |= | De droite à gauche |
| 14 | , | De gauche à droite |