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

object Test {
   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

object Test {
   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

object Test {
   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 :

OperatorDescriptionExemple
&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 à gauchea << 2 donne 240, explication binaire : 1111 0000
>>Opérateur de décalage à droitea >> 2 donne 15, explication binaire : 0000 1111
>>> Décalage à droite non signé A >>> 2 donne 15, explication binaire : 0000 1111

Exemple

Exemple

object Test {
   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

object Test {
   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
Autres extensions