Ruby Operatoren
Ruby unterstützt einen reichhaltigen Satz von Operatoren. Die meisten Operatoren sind tatsächlich Methodenaufrufe. Zum Beispiel wird a + b als a.+(b) interpretiert, wobei die Methode + auf der Variablen a aufgerufen wird und b als Argument an den Methodenaufruf übergeben wird.
Für jeden Operator (+ - * / % ** & | ^ << >> && ||) gibt es einen entsprechenden abgekürzten Zuweisungsoperator (+= -= und so weiter).
Ruby-Arithmetik-Operatoren
Angenommen, Variable a ist 10 und Variable b ist 20, dann:
| Operator | Beschreibung | Beispiel |
|---|---|---|
| + | Addition - Addiert die Operanden auf beiden Seiten des Operators. | a + b ergibt 30 |
| - | Subtraktion - Subtrahiert den rechten Operanden vom linken Operanden. | a - b ergibt -10 |
| * | Multiplikation - Multipliziert die Operanden auf beiden Seiten des Operators. | a * b ergibt 200 |
| / | Division - Dividiert den linken Operanden durch den rechten Operanden. | b / a ergibt 2 |
| % | Modulus - Dividiert den linken Operanden durch den rechten Operanden und gibt den Rest zurück. | b % a ergibt 0 |
| ** | Exponent - Führt die Potenzierung durch. | a**b ergibt 10 hoch 20 |
Ruby-Vergleichsoperatoren
Angenommen, Variable a ist 10 und Variable b ist 20, dann:
| Operator | Beschreibung | Beispiel |
|---|---|---|
| == | Prüft, ob die Werte zweier Operanden gleich sind; wenn ja, wird die Bedingung wahr. | (a == b) ist nicht wahr. |
| != | Prüft, ob die Werte zweier Operanden gleich sind; wenn sie nicht gleich sind, wird die Bedingung wahr. | (a != b) ist wahr. |
| > | Prü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. |
| < | Prü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. |
| >= | Prü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. |
| <= | Prü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. |
| <=> | Kombinierter Vergleichsoperator. Gibt 0 zurück, wenn der erste Operand gleich dem zweiten Operanden ist, 1, wenn der erste Operand größer als der zweite Operand ist, und -1, wenn der erste Operand kleiner als der zweite Operand ist. | (a <=> b) gibt -1 zurück. |
| === | Wird verwendet, umcase-Gleichheit innerhalb der when-Klausel einer case-Anweisung zu testen. | (1...10) === 5 gibt true zurück. |
| .eql? | Gibt true zurück, wenn der Empfänger und das Argument denselben Typ und gleiche Werte haben. | 1 == 1.0 gibt true zurück, aber 1.eql?.eql?(1.0) gibt false zurück. |
| equal? | Gibt true zurück, wenn der Empfänger und das Argument dieselbe Objekt-ID haben. | Wenn aObj eine Kopie von bObj ist, dann gibt aObj == bObj true zurück, a.equal?.equal? bObj gibt false zurück, aber a.equal?.equal? aObj gibt true zurück. |
Ruby-Zuweisungsoperatoren
Angenommen, Variable a ist 10 und Variable b ist 20, dann:
| Operator | Beschreibung | Beispiel |
|---|---|---|
| = | Einfacher Zuweisungsoperator. Weist dem linken Operanden den Wert des rechten Operanden zu. | c = a + b weist c den Wert von a + b zu. |
| += | Additions- und Zuweisungsoperator. Addiert den rechten Operanden zum linken Operanden und weist das Ergebnis dem linken Operanden zu. | c += a entspricht c = c + a. |
| -= | Subtraktions- und Zuweisungsoperator. Subtrahiert den rechten Operanden vom linken Operanden und weist das Ergebnis dem linken Operanden zu. | c -= a ist äquivalent zu c = c - a. |
| *= | Multiplikations- und Zuweisungsoperator. Multipliziert den rechten Operanden mit dem linken Operanden und weist das Ergebnis dem linken Operanden zu. | c *= a ist äquivalent zu c = c * a. |
| /= | Divisions- und Zuweisungsoperator. Dividiert den linken Operanden durch den rechten Operanden und weist das Ergebnis dem linken Operanden zu. | c /= a ist äquivalent zu c = c / a. |
| %= | Modulo- und Zuweisungsoperator. Ermittelt den Modulus der beiden Operanden und weist ihn dem linken Operanden zu. | c %= a ist äquivalent zu c = c % a. |
| **= | Potenz- und Zuweisungsoperator. Führt eine Potenzierung durch und weist das Ergebnis dem linken Operanden zu. | c **= a ist äquivalent zu c = c ** a. |
Parallele Zuweisung in Ruby
Ruby unterstützt außerdem die parallele Zuweisung von Variablen. Dadurch können mehrere Variablen in einer einzigen Zeile Ruby-Code initialisiert werden. Zum Beispiel:
Mit paralleler Zuweisung können Sie schneller deklarieren:
Parallele Zuweisung ist auch nützlich beim Vertauschen der Werte zweier Variablen:
Bitweise Operatoren in Ruby
Bitweise Operatoren arbeiten mit Bits und führen Operationen Bit für Bit aus.
Angenommen a = 60 und b = 13, im Binärformat sehen sie folgendermaßen aus:
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
Die folgende Tabelle listet die von Ruby unterstützten bitweisen Operatoren auf.
| Operator | Beschreibung | Beispiel |
|---|---|---|
| & | Der binäre AND-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 OR-Operator kopiert ein Bit in das Ergebnis, wenn es in einem der Operanden vorhanden ist. | (a | b) ergibt 61, was 0011 1101 ist |
| ^ | Der binäre XOR-Operator kopiert ein Bit in das Ergebnis, wenn es in einem der Operanden, aber nicht in beiden vorhanden ist. | (a ^ b) ergibt 49, was 0011 0001 ist |
| ~ | Der binäre Komplement-Operator ist ein unärer Operator, der die Wirkung hat, Bits "umzudrehen", d. h., 0 wird zu 1 und 1 wird zu 0. | (~a ) ergibt -61, was 1100 0011 in der Zweierkomplement-Darstellung einer vorzeichenbehafteten Binärzahl ist. |
| << | Binärer Linksverschiebungsoperator. Der Wert des linken Operanden wird um die Anzahl der vom rechten Operanden angegebenen Bits nach links verschoben. | a << 2 ergibt 240, was 1111 0000 ist |
| >> | Binärer Rechtsverschiebeoperator. Der Wert des linken Operanden wird um die Anzahl der durch den rechten Operanden angegebenen Bits nach rechts verschoben. | a >> 2 ergibt 15, was 0000 1111 ist |
Logische Operatoren in Ruby
Die folgende Tabelle listet die von Ruby unterstützten logischen Operatoren auf.
Angenommen, Variable a ist 10 und Variable b ist 20, dann:
| Operator | Beschreibung | Beispiel |
|---|---|---|
| und | Wird als logischer AND-Operator bezeichnet. Wenn beide Operanden wahr sind, wird die Bedingung wahr. | (a and b) ist wahr. |
| oder | Wird als logischer OR-Operator bezeichnet. Wenn einer der Operanden ungleich null ist, wird die Bedingung wahr. | (a or b) ist wahr. |
| && | Wird als logischer AND-Operator bezeichnet. Wenn beide Operanden ungleich null sind, wird die Bedingung wahr. | (a && b) ist wahr. |
| || | Wird als logischer OR-Operator bezeichnet. Wenn einer der Operanden ungleich null ist, wird die Bedingung wahr. | (a || b) ist wahr. |
| ! | Wird als logischer NOT-Operator bezeichnet. Wird verwendet, um den logischen Zustand eines Operanden umzukehren. Wenn die Bedingung wahr ist, macht der logische NOT-Operator sie falsch. | !(a && b) ist falsch. |
| not | Wird als logischer NOT-Operator bezeichnet. Wird verwendet, um den logischen Zustand eines Operanden umzukehren. Wenn die Bedingung wahr ist, macht der logische NOT-Operator sie falsch. | not(a && b) ist falsch. |
Ternärer Operator in Ruby
Ein Operator mit mehr als einem Operanden wird als ternärer Operator bezeichnet. Zuerst wertet er den Wahrheitswert eines Ausdrucks aus und entscheidet dann anhand des Ergebnisses, welche der beiden folgenden Anweisungen ausgeführt werden soll. Die Syntax des Bedingungsoperators lautet wie folgt:
| Operator | Beschreibung | Beispiel |
|---|---|---|
| ? : | Bedingter Ausdruck | Wenn Bedingung wahr ist ? dann Wert X : sonst Wert Y |
Range-Operatoren in Ruby
In Ruby werden Sequenzbereiche verwendet, um eine Reihe aufeinanderfolgender Werte zu erzeugen – die den Startwert, den Endwert (je nach Situation) und die dazwischenliegenden Werte enthält.
In Ruby werden diese Sequenzen mit den Range-Operatoren ".." und "..." erstellt. Die Zwei-Punkte-Form erzeugt einen Bereich, der den Start- und Endwert einschließt, während die Drei-Punkte-Form einen Bereich erzeugt, der nur den Startwert einschließt und den Endwert nicht einschließt.
| Operator | Beschreibung | Beispiel |
|---|---|---|
| .. | Erzeugt einen Bereich vom Startpunkt bis zum Endpunkt (einschließlich des Endpunkts) | 1..10 erzeugt einen Bereich von 1 bis 10 |
| ... | Erzeugt einen Bereich vom Startpunkt bis zum Endpunkt (ausschließlich des Endpunkts) | 1...10 erzeugt einen Bereich von 1 bis 9 |
Ruby defined?-Operator
defined? ist ein spezieller Operator, der die Form eines Methodenaufrufs annimmt, um zu bestimmen, ob der übergebene Ausdruck definiert ist. Er gibt einen Beschreibungsstring des Ausdrucks zurück, und wenn der Ausdruck nicht definiert ist, gibt ernil zurück。
Im Folgenden finden sich verschiedene Verwendungen des defined?-Operators:
Verwendung 1
Beispiel:
Verwendung 2
Beispiel:
Verwendung 3
Beispiel:
Verwendung 4
Beispiel:
Ruby-Punktoperator "." und Doppeldoppelpunkt-Operator "::"
Sie können eine Methode in einer Klasse oder einem Modul aufrufen, indem Sie dem Methodennamen den Klassen- oder Modulnamen voranstellen und.um eine Methode in einer Klasse oder einem Modul aufzurufen. Sie können den Klassen- oder Modulnamen und zwei Doppelpunkte verwenden::um auf eine Konstante innerhalb einer Klasse oder eines Moduls zu verweisen.
::ist ein unärer Operator, mit dem Sie Konstanten, Instanzmethoden und Klassenmethoden innerhalb einer Klasse oder eines Moduls definieren können, die von überall außerhalb der Klasse oder des Moduls aus zugänglich sind.
Denken Sie daran:In Ruby können Klassen und Methoden auch als Konstanten behandelt werden.
Sie müssen dem Konstantennamen im Ausdruck nur ein::Präfix voranstellen, um das entsprechende Klassen- oder Modulobjekt zurückzugeben.
Wenn::der Ausdruck vor dem Präfix ein Klassen- oder Modulname ist, gibt es den entsprechenden Konstantenwert innerhalb dieser Klasse oder dieses Moduls zurück; wenn::kein Präfixausdruck davor steht, gibt es den entsprechenden Konstantenwert in der Hauptklasse Object zurück.
Die folgenden beiden Beispiele:
Zweites Beispiel:
Ruby-Operatorrangfolge
Die folgende Tabelle listet alle Operatoren in der Reihenfolge ihrer Priorität von der höchsten zur niedrigsten auf.
| Methode | Operator | Beschreibung |
|---|---|---|
| Ja | :: | Konstantenauflösungsoperator |
| Ja | [ ] [ ]= | Elementreferenz, Elementzuweisung |
| Ja | ** | Potenzierung |
| Ja | ! ~ + - | Nicht, Komplement, unäres Plus, unäres Minus (die letzten beiden haben die Methodennamen +@ und -@) |
| Ja | * / % | Multiplikation, Division, Modulo |
| Ja | + - | Addition und Subtraktion |
| Ja | >> << | Bitweise Rechtsverschiebung, bitweise Linksverschiebung |
| Ja | & | Bitweises AND |
| Ja | ^ | | Bitweises XOR, bitweises OR |
| Ja | <= < > >= | Vergleichsoperatoren |
| Ja | <=> == === != =~ !~ | Gleichheits- und Musterabgleichsoperatoren (!= und !~ können nicht als Methoden definiert werden) |
| && | Logisches AND | |
| || | Logisches OR | |
| .. ... | Bereich (inklusiv, exklusiv) | |
| ? : | Ternäres if-then-else | |
| = %= { /= -= += |= &= >>= <<= *= &&= ||= **= | Zuweisung | |
| defined? | Prüfen, ob das angegebene Symbol definiert ist | |
| not | Logische Negation | |
| or und and | Logische Verknüpfung |
Hinweis:In der Methodenspalte sind die alsJamarkierten Operatoren tatsächlich Methoden und können daher überladen werden.
Weitere Erweiterungen