Ruby Operators

Ruby Arithmetische Operatoren

Annehmen, dass der Wert der Variable a 10，Variable b hat den Wert 20, dann:

Ruby-Vergleichsoperator

Annehmen, dass der Wert der Variable a 10，Variable b hat den Wert 20, dann:

Ruby-Zuweisungsoperator

Annehmen, dass der Wert der Variable a 10，Variable b hat den Wert 20, dann:

Ruby Parallelzuweisung

Ruby unterstützt auch die parallele Zuweisung von Variablen. Dies ermöglicht es mehreren Variablen, durch eine Zeile Ruby-Code initialisiert zu werden. Zum Beispiel:

a　=　10
b　=　20
c　=　30

Mit Parallelzuweisungen kann schneller deklariert werden:

a,　b,　c　=　10,　20,　30

Parallelzuweisungen sind auch nützlich, um die Werte zweier Variablen auszutauschen:

a,　b　=　b,　c

Ruby Bit-Operatoren

Bit-Operatoren wirken auf Bits und führen Operationen bitweise aus.

Annehmen, wenn a = 60, und b = 13，nun in binärem Format, sie sehen so aus:

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a　 = 1100 0011

Die nachstehende Tabelle zeigt die bitweisen Operatoren, die Ruby unterstützt.

Ruby logische Operatoren

Die nachstehende Tabelle zeigt die logischen Operatoren, die Ruby unterstützt.

Annehmen, dass der Wert der Variable a 10，Variable b hat den Wert 20, dann:

Ruby bedingter Operator

Es gibt mehr als eine Operation, die als bedingter Operator bezeichnet wird. Der erste berechnet den wahren oder falschen Wert des Ausdrucks und entscheidet dann entsprechend dieses Ergebnisses, welche der beiden folgenden Anweisungen ausgeführt wird. Die Syntax des bedingten Operators ist wie folgt：

Ruby Bereichsoperator

in Ruby werden Bereichreihen verwendet, um eine Reihe von aufeinanderfolgenden Werten zu erstellen - enthält den Anfangswert, den Endwert (je nach Fall) und die Werte dazwischen.

In Ruby werden diese Reihen durch die ".." und "..."-Bereichsoperator erstellt. Der durch das Zweipunktsymbol erstellte Bereich enthält den Anfangswert und den Endwert, der durch das Dreipunktsymbol erstellte Bereich enthält nur den Anfangswert und nicht den Endwert.

Ruby defined? Operator

definiert? ist ein spezieller Operator, der wie eine Methodenaufrufform verwendet wird, um zu bestimmen, ob ein übergebener Ausdruck definiert ist. Er gibt die Beschreibungszeichenkette des Ausdrucks zurück und gibt bei einem nicht definierten Ausdruck nil.

Hier sind verschiedene Verwendungen des Operators defined?：

Verwendung 1

definiert?　variable　#　wenn　variable　bereits initialisiert wurde，dann True

Beispiel：

foo　=　42
definiert?　foo　#　=>　"local"-variable"
definiert?　$_　#　=>　"global"-variable"
definiert?　bar　#　=>　nil（nicht definiert）

Verwendung 2

definiert?　method_call　#　wenn die Methode bereits definiert ist，dann True

Beispiel：

definiert?　puts　#　=>　"method"
definiert?　puts(bar)　#　=>　nil（hier　bar　nicht definiert）
definiert?　unpack　#　=>　nil（hier nicht definiert）

Verwendung 3

#　wenn es Methoden gibt，die durch　super　aufrufbar sind，dann True
definiert?　super

Beispiel：

definiert?　super　#　=>　"super"（wenn aufrufbar）
definiert?　super　#　=>　nil（wenn nicht aufrufbar）

Verwendung 4

definiert?　yield　#　wenn ein Codeblock übergeben wurde，dann True

Beispiel：

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

Ruby-Punktoperator "." und der doppelte Doppelpunktoperator "::"

Du kannst Methoden in einer Klasse oder einem Modul aufrufen, indem du den Klass- oder Modulnamen vor den Methodennamen und . setzt. Du kannst Konstanten in einer Klasse oder einem Modul referenzieren, indem du den Klass- oder Modulnamen und zwei Doppelpunkte :: setzt.

:: ist ein unärer Operator, der das Definieren von Konstanten, Beispielmethoden und Klassenmethoden innerhalb einer Klasse oder eines Moduls ermöglicht und von jedem Ort außerhalb der Klasse oder des Moduls zugänglich ist.

Denk daran:In Ruby können Klassen und Methoden auch als Konstanten verwendet werden.

Du musst nur den Konstantennamen vor dem Ausdruck setzen :: Präfix, um den angemessenen Klass- oder Modulobjekt zurückzugeben.

Wenn das Ausdruck vor :: ein Klassname oder Modulname ist, wird der entsprechende Konstantenwert der Klasse oder des Moduls zurückgegeben; wenn vor :: kein Präfixausdruck vorhanden ist, wird der entsprechende Konstantenwert der Hauptklasse Object zurückgegeben. .

Hier sind zwei Beispiele:

MR_COUNT = 0 # Definiert in der Hauptklasse Object
module Foo
　　MR_COUNT = 0
　　::MR_COUNT =　1　　　　# Setze den globalen Zähler　1
　　MR_COUNT =　2　　　　　　# Setze den lokalen Zähler　2
end
puts MR_COUNT # Dies ist die globale Konstante
puts Foo::MR_COUNT # Dies ist die lokale Konstante von "Foo"

Zweiter Beispiel:

CONST = 'out there'
class Inside_one
　　　CONST = proc {'in there'}
　　　def where_is_my_CONST
　　　　　　::CONST　+　'inside 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

Priorität der Ruby-Operator

Die folgende Tabelle listet alle Operator in der Reihenfolge der Priorität von hoch nach niedrig auf.

Note:is marked in the method list as is The operators are actually methods, so they can be overloaded.