Scala - Betreiber
Ein Operator ist ein Symbol, das den Compiler anweist, bestimmte mathematische oder logische Manipulationen durchzuführen. Scala ist reich an integrierten Operatoren und bietet die folgenden Arten von Operatoren:
- Rechenzeichen
- Vergleichsoperatoren
- Logische Operatoren
- Bitweise Operatoren
- Zuweisungsoperatoren
In diesem Kapitel werden die arithmetischen, relationalen, logischen, bitweisen, Zuweisungs- und anderen Operatoren nacheinander untersucht.
Rechenzeichen
Die folgenden arithmetischen Operatoren werden von der Scala-Sprache unterstützt. Nehmen wir zum Beispiel an, Variable A hält 10 und Variable B hält 20, dann -
Beispiele anzeigen
| Operator | Beschreibung | Beispiel |
|---|---|---|
| + | Fügt zwei Operanden hinzu | A + B ergibt 30 |
| - - | Subtrahiert den zweiten Operanden vom ersten | A - B ergibt -10 |
| * * | Multipliziert beide Operanden | A * B ergibt 200 |
| /. | Teilt den Zähler durch den De-Zähler | B / A ergibt 2 |
| %. | Der Moduloperator findet den Rest nach Division einer Zahl durch eine andere | B% A ergibt 0 |
Vergleichsoperatoren
Die folgenden Vergleichsoperatoren werden von der Scala-Sprache unterstützt. Nehmen wir zum Beispiel an, Variable A hält 10 und Variable B hält 20, dann -
Beispiele anzeigen
| Operator | Beschreibung | Beispiel |
|---|---|---|
| == | Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn ja, wird die Bedingung wahr. | (A == B) ist nicht wahr. |
| ! = | Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr. | (A! = B) ist wahr. |
| > | Überprüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A> B) ist nicht wahr. |
| < | Überprüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A <B) ist wahr. |
| > = | Überprüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A> = B) ist nicht wahr. |
| <= | Überprüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A <= B) ist wahr. |
Logische Operatoren
Die folgenden logischen Operatoren werden von der Scala-Sprache unterstützt. Angenommen, Variable A hält 1 und Variable B hält 0, dann -
Beispiele anzeigen
| Operator | Beschreibung | Beispiel |
|---|---|---|
| && | Es heißt logischer UND-Operator. Wenn beide Operanden nicht Null sind, wird die Bedingung wahr. | (A && B) ist falsch. |
| || | Es heißt logischer ODER-Operator. Wenn einer der beiden Operanden nicht Null ist, wird die Bedingung wahr. | (A || B) ist wahr. |
| ! | Es heißt Logical NOT Operator. Verwenden Sie diese Option, um den logischen Status des Operanden umzukehren. Wenn eine Bedingung wahr ist, macht der Operator Logical NOT false. | ! (A && B) ist wahr. |
Bitweise Operatoren
Der bitweise Operator bearbeitet Bits und führt eine bitweise Operation durch. Die Wahrheitstabellen für &, | und ^ lauten wie folgt:
| 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 |
Angenommen, A = 60; und B = 13; jetzt im Binärformat werden sie wie folgt sein -
A = 0011 1100
B = 0000 1101
-----------------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011Die von der Scala-Sprache unterstützten bitweisen Operatoren sind in der folgenden Tabelle aufgeführt. Angenommen, Variable A hält 60 und Variable B hält 13, dann -
Beispiele anzeigen
| Operator | Beschreibung | Beispiel |
|---|---|---|
| & | Der binäre UND-Operator kopiert ein Bit in das Ergebnis, wenn es in beiden Operanden vorhanden ist. | (A & B) ergibt 12, was 0000 1100 ist |
| | | Der binäre ODER-Operator kopiert ein Bit, wenn es in einem der Operanden vorhanden ist. | (A | B) ergibt 61, was 0011 1101 ist |
| ^ | Der binäre XOR-Operator kopiert das Bit, wenn es in einem Operanden gesetzt ist, aber nicht in beiden. | (A ^ B) ergibt 49, was 0011 0001 ist |
| ~ | Der Komplementoperator für binäre Einsen ist unär und bewirkt das Umdrehen von Bits. | (~ A) ergibt -61, was aufgrund einer vorzeichenbehafteten Binärzahl 1100 0011 in 2er-Komplementform ist. |
| << | Binärer Linksschaltoperator. Die Bitpositionen des Werts der linken Operanden werden um die vom rechten Operanden angegebene Anzahl von Bits nach links verschoben. | Ein << 2 ergibt 240, was 1111 0000 ist |
| >> | Binärer Rechtsschieber. Die Bitpositionen des linken Operandenwerts werden um die vom rechten Operanden angegebene Anzahl von Bits nach rechts verschoben. | Eine >> 2 ergibt 15, was 1111 ist |
| >>> | Verschieben Sie den Nullfüllungsoperator nach rechts. Der Wert der linken Operanden wird um die vom rechten Operanden angegebene Anzahl von Bits nach rechts verschoben, und verschobene Werte werden mit Nullen gefüllt. | Eine >>> 2 ergibt 15, was 0000 1111 ist |
Zuweisungsoperatoren
Es gibt folgende Zuweisungsoperatoren, die von der Scala-Sprache unterstützt werden:
Beispiele anzeigen
| Operator | Beschreibung | Beispiel |
|---|---|---|
| = | Einfacher Zuweisungsoperator, Weist Werte von Operanden auf der rechten Seite dem Operanden auf der linken Seite zu | C = A + B weist C den Wert von A + B zu |
| + = | UND-Zuweisungsoperator hinzufügen. Er fügt dem linken Operanden den rechten Operanden hinzu und weist das Ergebnis dem linken Operanden zu | C + = A entspricht C = C + A. |
| - = | Subtrahieren UND Zuweisungsoperator, subtrahiert den rechten Operanden vom linken Operanden und weist das Ergebnis dem linken Operanden zu | C - = A entspricht C = C - A. |
| * = | Multiplizieren Sie den UND-Zuweisungsoperator. Er multipliziert den rechten Operanden mit dem linken Operanden und weist das Ergebnis dem linken Operanden zu | C * = A entspricht C = C * A. |
| / = | UND-Zuweisungsoperator teilen. Er teilt den linken Operanden mit dem rechten Operanden und weist das Ergebnis dem linken Operanden zu | C / = A entspricht C = C / A. |
| % = | Modul- UND Zuweisungsoperator. Der Modul wird mit zwei Operanden verwendet und das Ergebnis dem linken Operanden zugewiesen | C% = A entspricht C = C% A. |
| << = | Linksverschiebung UND Zuweisungsoperator | C << = 2 ist dasselbe wie C = C << 2 |
| >> = | Rechtsverschiebung UND Zuweisungsoperator | C >> = 2 ist dasselbe wie C = C >> 2 |
| & = | Bitweiser UND-Zuweisungsoperator | C & = 2 ist dasselbe wie C = C & 2 |
| ^ = | bitweises exklusives ODER und Zuweisungsoperator | C ^ = 2 ist dasselbe wie C = C ^ 2 |
| | = | bitweises Inklusiv-ODER und Zuweisungsoperator | C | = 2 ist dasselbe wie C = C | 2 |
Vorrang der Betreiber in Scala
Die Operatorrangfolge bestimmt die Gruppierung von Begriffen in einem Ausdruck. Dies wirkt sich darauf aus, wie ein Ausdruck ausgewertet wird. Bestimmte Operatoren haben eine höhere Priorität als andere. Beispielsweise hat der Multiplikationsoperator eine höhere Priorität als der Additionsoperator -
Zum Beispiel ist x = 7 + 3 * 2; Hier wird x 13 zugewiesen, nicht 20, da der Operator * eine höhere Priorität als + hat. Daher wird er zuerst mit 3 * 2 multipliziert und dann zu 7 addiert.
Schauen Sie sich die folgende Tabelle an. Operatoren mit der höchsten Priorität werden oben in der Tabelle und Operatoren mit der niedrigsten Priorität unten angezeigt. Innerhalb eines Ausdrucks werden zuerst Operatoren mit höherer Priorität ausgewertet.
| Kategorie | Operator | Assoziativität |
|---|---|---|
| Postfix | () [] | Links nach rechts |
| Einstellig | ! ~ | Rechts nach links |
| Multiplikativ | * /% | Links nach rechts |
| Zusatzstoff | + - | Links nach rechts |
| Verschiebung | >> >>> << | Links nach rechts |
| Relational | >> = << = | Links nach rechts |
| Gleichberechtigung | ==! = | Links nach rechts |
| Bitweises UND | & | Links nach rechts |
| Bitweises XOR | ^ | Links nach rechts |
| Bitweises ODER | | | Links nach rechts |
| Logisches UND | && | Links nach rechts |
| Logisches ODER | || | Links nach rechts |
| Zuordnung | = + = - = * = / =% = >> = << = & = ^ = | = | Rechts nach links |
| Komma | , | Links nach rechts |