Opérateurs Scala

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) ;
　　　}
}

Exécuter le code suivant, le résultat est :

$　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 liste les opérateurs logiques pris en charge par Scala.

Assumons que la variable A est 1B est 0 :

Exemple en ligne

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) ;
　　　}
}

Exécuter le code suivant, le résultat est :

$　scalac　Test.scala　
$　scala　Test
a && b = false
a || b = true
!(a && b) = true

Opérateurs de bit

Les opérateurs de bit opèrent sur les bits, ~,&,|,^ représentent respectivement la négation, le ET bit à bit, l'OU bit à bit et l'XOR bit à bit, comme illustré ci-dessous :

Si A est spécifié : 60; et B = 13; Les binaires des deux variables sont :

A = 0011　1100
B = 0000　1101
-------Opérations bit à bit----------
A&B = 0000　1100
A|B = 0011　1101
A^B = 0011　0001
~A =　1100 0011

Les règles des opérations binaires en Scala sont les suivantes :

Exemple en ligne

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　);
　　　}
}

Exécuter le code suivant, le résultat est :

$　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

Voici les opérateurs d'affectation pris en charge par la langue Scala :

Exemple en ligne

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　);
　　　}
}

Exécuter le code suivant, le résultat est :

$　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 ils appartiennent, ce qui affecte le calcul de l'expression.

Exemple : x = 7 + 3 * 2; ici, le résultat de x est 13, et non 20, car la multiplication (*) a une priorité supérieure à l'addition (+) donc il calcule d'abord 3*2 Ajouter en plus 7.

Voyez le tableau suivant, la priorité diminue de haut en bas, le plus haut en haut a la priorité la plus élevée, et l'opérateur virgule a la priorité la plus basse.