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:

OperatorBeschreibungBeispiel
+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:

OperatorBeschreibungBeispiel
==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:

OperatorBeschreibungBeispiel
=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:

a = 10 b = 20 c = 30

Mit paralleler Zuweisung können Sie schneller deklarieren:

a, b, c = 10, 20, 30

Parallele Zuweisung ist auch nützlich beim Vertauschen der Werte zweier Variablen:

a, b = b, c

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.

OperatorBeschreibungBeispiel
&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:

OperatorBeschreibungBeispiel
undWird als logischer AND-Operator bezeichnet. Wenn beide Operanden wahr sind, wird die Bedingung wahr.(a and b) ist wahr.
oderWird 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.
notWird 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:

OperatorBeschreibungBeispiel
? :Bedingter AusdruckWenn 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.

OperatorBeschreibungBeispiel
..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

defined? variable #Wahr, wenn variable bereits initialisiert wurde

Beispiel:

foo = 42 defined? foo # => "local-variable" defined? $_ # => "global-variable" defined? bar #=> nil (undefiniert)

Verwendung 2

defined? method_call #Wahr, wenn die Methode definiert wurde

Beispiel:

defined? puts # => "method" defined? puts(bar) #=> nil (bar ist hier undefiniert) defined? unpack #=> nil (hier undefiniert)

Verwendung 3

#Wahr, wenn eine Methode existiert, die von super aufgerufen werden kann defined? super

Beispiel:

defined? super #=> "super" (wenn es aufgerufen werden kann) defined? super #=> nil (wenn es nicht aufgerufen werden kann)

Verwendung 4

defined? yield #Wahr, wenn ein Block übergeben wurde

Beispiel:

defined? yield #=> "yield" (wenn ein Block übergeben wurde) defined? yield #=> nil (wenn kein Block übergeben wurde)

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:

MR_COUNT = 0 #Konstante, definiert in der Hauptklasse Object module Foo MR_COUNT = 0 ::MR_COUNT = 1 #Globalen Zähler auf 1 setzen MR_COUNT = 2 #Lokalen Zähler auf 2 setzen end puts MR_COUNT #Dies ist die globale Konstante puts Foo::MR_COUNT #Dies ist die lokale Konstante von "Foo"

Zweites Beispiel:

CONST = ' dort draußen' class Inside_one CONST = proc {' dort drinnen'} def where_is_my_CONST ::CONST + ' innerhalb von one' end end class Inside_two CONST = ' inside two' def where_is_my_CONST CONST end end puts Inside_one.new.where_is_my_CONST puts Inside_two.new.where_is_my_CONST puts Object::CONST + Inside_two::CONST puts Inside_two::CONST + CONST puts Inside_one::CONST puts Inside_one::CONST.call + Inside_two::CONST

Ruby-Operatorrangfolge

Die folgende Tabelle listet alle Operatoren in der Reihenfolge ihrer Priorität von der höchsten zur niedrigsten auf.

MethodeOperatorBeschreibung
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