Najlepszy samouczek operator Scala W 2024 r. W tym samouczku możesz dowiedzieć się operatory arytmetyczne,operatory relacyjne,Operatory logiczne,Operatory bitowe,Operatory przypisania,Priorytet operatorów,
Operator jest symbolem, używany do poinformować kompilator do wykonania określonej operacji matematycznych i logicznych.
Scala bogate wbudowanych operatorów, w tym następujących typów:
operatory arytmetyczne
operatory relacyjne
Operatory logiczne
Operatory bitowe
Operatory przypisania
Następnie będziemy wyjaśniać ci więcej niż stosowanie różnych operatorów.
W poniższej tabeli wymieniono operatory arytmetyczne wsparcie Scala.
Zmienna przyjęto jako 10, B 20:
operatorzy | opis | Przykłady |
---|---|---|
+ | plus | Wynik operacji jest 30 + B |
- | minus | A - B wynik operacji wynosi -10 |
* | Mnożenie znak | A * B wynik operacji wynosi 200 |
/ | Znak podziału | B / A wynik operacji wynosi 2 |
% | reszta | B% Wynik obliczeń jest 0 |
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) ); } }
Realizacja powyższego kodu, wyjście jest:
$ scalac Test.scala $ scala Test a + b = 30 a - b = -10 a * b = 200 b / a = 2 b % a = 0 c % a = 5
Poniższa tabela zawiera Scala wspierać operatorów relacyjnych.
Zmienna przyjęto jako 10, B 20:
operatorzy | opis | Przykłady |
---|---|---|
== | równy | (A == B) wynik operacji jest fałszywy |
! = | Nie jest równy | (A! = B) wynik operacji jest prawdą |
> | większy niż | (A> B) wynik operacji jest fałszywy |
< | mniej niż | (A <b) wynik operacji jest prawdą |
> = | Większe lub równe | (A> = B) wynik operacji jest fałszywy |
<= | Mniejszy lub równy | (A <= B) wynik operacji jest prawdą |
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) ); } }
Realizacja powyższego kodu, wyjście jest:
$ scalac Test.scala $ scala Test a == b = false a != b = true a > b = false a < b = true b >= a = true b <= a = false
Poniższa tabela zawiera Scala wspiera operatorów logicznych.
Zmienna przyjęto jako 1, B jest 0:
operatorzy | opis | Przykłady |
---|---|---|
&& | Logika i | (A && B) wynik operacji jest fałszywy |
|| | logiczna lub | (A || B) wynik operacji jest prawdą |
! | logiczne NIE | ! (A && B) wynik operacji jest prawdą |
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) ); } }
Realizacja powyższego kodu, wyjście jest:
$ scalac Test.scala $ scala Test a && b = false a || b = true !(a && b) = true
Operatorzy bitowe bity wykorzystywane do obsługi, ~ i, | ^ zostały zanegowany, a bit lub po kroku, a bitowe operacji XOR następującymi przykładami tabeli:
p | q | P & P | p | q | p ^ q |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
Jeśli A = 60; B = 13; dwie zmienne odpowiadające binarnym:
A = 0011 1100 B = 0000 1101 -------位运算---------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001 ~A = 1100 0011
Scala bitowe reguły w następujący sposób:
operatorzy | opis | Przykłady |
---|---|---|
& | Bitowe Operator AND | (A i B), wyjście 12, wyjaśnienie binarny: 0000 1100 |
| | Operator OR bitowe | (A | b) Wyjście 61, binarny wyjaśnienie: 00111101 |
^ | Bitowe wyłącznym operatorem OR | (A ^ B) wyjście 49, wyjaśnienie binarny: 00110001 |
~ | Operatory bitowe | (~ A) -61 wyjście wyjaśnienie binarny: 1100 0011 w formie symbolicznej uzupełniają liczbę binarną. |
<< | Lewa operator komórkowy | << 2 wyjścia 240 Binary interpretacja: 11110000 |
>> | Prawo operatorów telefonii komórkowej | >> dwa wyjścia 15, wyjaśnienie binarny: 0000 1111 |
>>> | Niepodpisany prawym shift | A >>> 2 wyjścia binarne wyjaśnienie: 15 0000 1111 |
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; /* 215 = 1111 */ println("a >> 2 = " + c ); c = a >>> 2; /* 215 = 0000 1111 */ println("a >>> 2 = " + c ); } }
Realizacja powyższego kodu, wyjście jest:
$ 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
Poniższa lista operatora Scala języka Przypisanie wsparcia:
operatorzy | opis | Przykłady |
---|---|---|
= | Proste operator przypisania, określa prawy operand przypisaną do lewego argumentu. | Wynik C = A + B A + B Działanie jest przypisany do C |
+ = | Dodanie po cesji, lewa i prawa strona tego argumentu przed dodaniem przypisane do lewego argumentu. | C + = A odpowiada = C + A |
- = | Po cesji odejmowania, lewy i prawy argumenty po obu stronach lewego operandu po odjęciu przypisany. | C - = A odpowiada = C - A |
* = | Następnie mnożąc zadanie, po lewej i prawej strony operandów są mnożone przed przydzieleniem do lewego argumentu. | C * = A odpowiada = C * A |
/ = | Podzielone po cesji, lewa i prawa strona tego argumentu dzielącym po przydzieleniu do lewego argumentu. | C / = A jest równoważne C = C / A |
% = | Pozostałą po cesji, lewa i prawa strona tego argumentu pozostałej po przydzieleniu do lewego argumentu. | C% = A jest równoważne = C% A |
<< = | Bitowe w lewo po cesji | C << = 2 odpowiada = C << 2 |
>> = | Bitowe tuż po cesji | C >> = 2 jest równa = C >> 2 |
& = | Bitowe i przyporządkowanie po operacji | C & = 2 jest równa C = C 2 |
^ = | Bitowe wyłączną operator OR, a następnie przypisano | C ^ = 2 jest równa = C ^ 2 |
| = | Bitowe lub cesja po | C | = 2 odpowiada = C | 2 |
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 >>= 2 ; println("c >>= a = " + c ); c &= a ; println("c &= 2 = " + c ); c ^= a ; println("c ^= a = " + c ); c |= a ; println("c |= a = " + c ); } }
Realizacja powyższego kodu, wyjście jest:
$ 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 = 1 c &= 2 = 0 c ^= a = 10 c |= a = 10
W wyrażeniu może zawierać wiele różnych operatorów łączących się z różnych typów danych obiektów danych, gdyż wyrażenie ma wiele operacji, inna kolejność operacji może mieć różne wyniki nawet błędne błąd operacji, bo gdy gdy ekspresyjny zawierający szereg operacji, zgodnie z określonym porządku muszą być łączone w celu zapewnienia racjonalnego i prawidłowość wyniki, wyjątkowość działania.
Priorytet w kolejności od góry do dołu, górna ma najwyższy priorytet, operator przecinka ma najniższy priorytet.
Ten sam poziom priorytetu, według kolejności wiązania obliczeń. Większość operacji są obliczane od lewej do prawej, tylko trzy priorytety są od prawej do lewej połączeniu, są operatory jednoargumentowe, operatory warunkowe, operatory przypisania.
Podstawowe priorytety trzeba pamiętać:
Rodzaj operator | operatorzy | Oprawa kierunek |
---|---|---|
ocena Expression | () []. Expr ++ expr-- | Od lewej do prawej |
operator jednoargumentowy | * & + - ~ ++ Expr --expr * /% + - >> << <> <=> = ==! = | Od prawej do lewej |
Operatory bitowe | & ^ | && || | Od lewej do prawej |
operator trójargumentowy | ?: | Od prawej do lewej |
Operatory przypisania | = + = - = * = / =% = >> = << = & = ^ = | = | Od prawej do lewej |
przecinek | , | Od lewej do prawej |