Ruby - Operatoren

Ruby unterstützt eine Vielzahl von Operatoren, wie Sie es von einer modernen Sprache erwarten würden. Die meisten Operatoren sind tatsächlich Methodenaufrufe. Zum Beispiel wird a + b als a. + (B) interpretiert, wobei die + -Methode in dem Objekt, auf das die Variable a verweist, mit b als Argument aufgerufen wird .

Für jeden Operator (+ - * /% ** & | ^ << >> && ||) gibt es eine entsprechende Form eines abgekürzten Zuweisungsoperators (+ = - = usw.).

Ruby-Arithmetikoperatoren

Angenommen, Variable a hält 10 und Variable b hält 20, dann -

Operator	Beschreibung	Beispiel
+	Addition - Fügt Werte auf beiden Seiten des Operators hinzu.	a + b ergibt 30
- -	Subtraktion - Subtrahiert den rechten Operanden vom linken Operanden.	a - b ergibt -10
* *	Multiplikation - Multipliziert Werte auf beiden Seiten des Operators.	a * b ergibt 200
/.	Division - Teilt den linken Operanden durch den rechten Operanden.	b / a ergibt 2
%.	Modul - Teilt den linken Operanden durch den rechten Operanden und gibt den Rest zurück.	b% a ergibt 0
** **.	Exponent - Führt eine Exponentialberechnung (Leistungsberechnung) für Operatoren durch.	a ** b gibt 10 zur Potenz 20

Ruby-Vergleichsoperatoren

Angenommen, Variable a hält 10 und Variable b hält 20, dann -

Operator	Beschreibung	Beispiel
==	Überprüft, ob der Wert von zwei Operanden gleich ist oder nicht. Wenn ja, wird die Bedingung wahr.	(a == b) ist nicht wahr.
! =	Überprüft, ob der Wert von zwei Operanden gleich ist 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.
<=>	Kombinierter Vergleichsoperator. Gibt 0 zurück, wenn der erste Operand gleich dem zweiten ist, 1, wenn der erste Operand größer als der zweite ist, und -1, wenn der erste Operand kleiner als der zweite ist.	(a <=> b) gibt -1 zurück.
===	Wird verwendet, um die Gleichheit innerhalb einer when-Klausel einer case- Anweisung zu testen .	(1 ... 10) === 5 gibt true zurück.
.eql?	True, wenn Empfänger und Argument denselben Typ und dieselben Werte haben.	1 == 1.0 gibt true zurück, aber 1.eql? (1.0) ist false.
gleich?	True, wenn Empfänger und Argument dieselbe Objekt-ID haben.	Wenn aObj ein Duplikat von bObj ist, dann ist aObj == bObj wahr, a.equal? ​​bObj ist falsch, aber a.equal? ​​aObj ist wahr.

Ruby-Zuweisungsoperatoren

Angenommen, Variable a hält 10 und Variable b hält 20, dann -

Operator	Beschreibung	Beispiel
=	Einfacher Zuweisungsoperator, weist dem linken Operanden Werte von Operanden auf der rechten Seite zu.	c = a + b weist c den Wert von a + b zu
+ =	Fügen Sie den AND-Zuweisungsoperator hinzu, fügen Sie dem linken Operanden den rechten Operanden hinzu und weisen Sie das Ergebnis dem linken Operanden zu.	c + = a entspricht c = c + a
- =	Subtrahieren Sie den UND-Zuweisungsoperator, subtrahieren Sie den rechten Operanden vom linken Operanden und weisen Sie das Ergebnis dem linken Operanden zu.	c - = a entspricht c = c - a
* =	Multiplizieren Sie den UND-Zuweisungsoperator, multiplizieren Sie den rechten Operanden mit dem linken Operanden und weisen Sie das Ergebnis dem linken Operanden zu.	c * = a entspricht c = c * a
/ =	Teilen Sie den UND-Zuweisungsoperator, teilen Sie den linken Operanden mit dem rechten Operanden und weisen Sie das Ergebnis dem linken Operanden zu.	c / = a entspricht c = c / a
% =	Modul UND Zuweisungsoperator, nimmt den Modul mit zwei Operanden und weist das Ergebnis dem linken Operanden zu.	c% = a entspricht c = c% a
** =	Exponent AND Zuweisungsoperator, führt Exponentialberechnung (Potenzberechnung) für Operatoren durch und weist dem linken Operanden einen Wert zu.	c ** = a entspricht c = c ** a

Ruby Parallel Assignment

Ruby unterstützt auch die parallele Zuweisung von Variablen. Dadurch können mehrere Variablen mit einer einzigen Zeile Ruby-Code initialisiert werden. Zum Beispiel -

a = 10
b = 20
c = 30

Dies kann durch parallele Zuweisung schneller deklariert werden -

a, b, c = 10, 20, 30

Die parallele Zuweisung ist auch nützlich, um die in zwei Variablen enthaltenen Werte auszutauschen.

a, b = b, c

Ruby Bitwise Operatoren

Der bitweise Operator arbeitet mit Bits und führt eine bitweise Operation durch.

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 0011

Die folgenden bitweisen Operatoren werden von der Ruby-Sprache unterstützt.

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. Der Wert der linken Operanden wird um die vom rechten Operanden angegebene Anzahl von Bits nach links verschoben.	a << 2 ergibt 240, was 1111 0000 ist
>>	Binärer Rechtsschieber. Der Wert der linken Operanden wird um die vom rechten Operanden angegebene Anzahl von Bits nach rechts verschoben.	Eine >> 2 ergibt 15, was 0000 1111 ist

Ruby Logical Operators

Die folgenden logischen Operatoren werden von der Ruby-Sprache unterstützt

Angenommen, Variable a hält 10 und Variable b hält 20, dann -

Operator	Beschreibung	Beispiel
und	Wird als logischer UND-Operator bezeichnet. Wenn beide Operanden wahr sind, wird die Bedingung wahr.	(a und b) ist wahr.
oder	Wird als logischer ODER-Operator bezeichnet. Wenn einer der beiden Operanden nicht Null ist, wird die Bedingung wahr.	(a oder b) ist wahr.
&&	Wird als logischer UND-Operator bezeichnet. Wenn beide Operanden nicht Null sind, wird die Bedingung wahr.	(a && b) ist wahr.
||	Wird als logischer ODER-Operator bezeichnet. Wenn einer der beiden Operanden nicht Null ist, wird die Bedingung wahr.	(a || b) ist wahr.
!	Wird als logischer NICHT-Operator bezeichnet. 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 falsch.
nicht	Wird als logischer NICHT-Operator bezeichnet. Verwenden Sie diese Option, um den logischen Status des Operanden umzukehren. Wenn eine Bedingung wahr ist, macht der Operator Logical NOT false.	nicht (a && b) ist falsch.

Ruby Ternary Operator

Es gibt noch einen Operator namens Ternary Operator. Es wertet zuerst einen Ausdruck für einen wahren oder falschen Wert aus und führt dann abhängig vom Ergebnis der Bewertung eine der beiden angegebenen Anweisungen aus. Der bedingte Operator hat diese Syntax -

Operator	Beschreibung	Beispiel
? ::	Bedingter Ausdruck	Wenn Bedingung wahr ist? Dann Wert X: Andernfalls Wert Y.

Ruby Range Operatoren

Sequenzbereiche in Ruby werden verwendet, um einen Bereich aufeinanderfolgender Werte zu erstellen - bestehend aus einem Startwert, einem Endwert und einem Wertebereich dazwischen.

In Ruby werden diese Sequenzen mit den Bereichsoperatoren ".." und "..." erstellt. Das Zwei-Punkt-Formular erstellt einen Inklusivbereich, während das Drei-Punkt-Formular einen Bereich erstellt, der den angegebenen hohen Wert ausschließt.

Operator	Beschreibung	Beispiel
..	Erstellt einen Bereich vom Startpunkt bis einschließlich Endpunkt.	1..10 Erstellt einen Bereich von 1 bis einschließlich 10.
...	Erstellt einen exklusiven Bereich vom Startpunkt bis zum Endpunkt.	1 ... 10 Erstellt einen Bereich von 1 bis 9.

Ruby definiert? Betreiber

definiert? ist ein spezieller Operator, der die Form eines Methodenaufrufs hat, um zu bestimmen, ob der übergebene Ausdruck definiert ist oder nicht. Es gibt eine Beschreibungszeichenfolge des Ausdrucks zurück oder null, wenn der Ausdruck nicht definiert ist.

Es gibt verschiedene Verwendungszwecke von definiert? Operator

Verwendungszweck 1

defined? variable # True if variable is initialized

For Example

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

Verwendung 2

defined? method_call # True if a method is defined

For Example

defined? puts        # => "method"
defined? puts(bar)   # => nil (bar is not defined here)
defined? unpack      # => nil (not defined here)

Verwendung 3

# True if a method exists that can be called with super user
defined? super

For Example

defined? super     # => "super" (if it can be called)
defined? super     # => nil (if it cannot be)

Verwendung 4

defined? yield   # True if a code block has been passed

For Example

defined? yield    # => "yield" (if there is a block passed)
defined? yield    # => nil (if there is no block)

Ruby Dot "." und Double Colon "::" Operatoren

Sie rufen eine Modulmethode auf, indem Sie ihrem Namen den Namen des Moduls und einen Punkt voranstellen und eine Konstante mit dem Modulnamen und zwei Doppelpunkten referenzieren.

Das :: ist ein unärer Operator, mit dem auf Konstanten, Instanzmethoden und Klassenmethoden, die in einer Klasse oder einem Modul definiert sind, von überall außerhalb der Klasse oder des Moduls zugegriffen werden kann.

Remember In Ruby können Klassen und Methoden auch als Konstanten betrachtet werden.

Sie müssen nur das Präfix :: Const_name mit einem Ausdruck, der das entsprechende Klassen- oder Modulobjekt zurückgibt.

Wenn kein Präfixausdruck verwendet wird, wird standardmäßig die Hauptobjektklasse verwendet.

Hier sind zwei Beispiele -

MR_COUNT = 0         # constant defined on main Object class
module Foo
   MR_COUNT = 0
   ::MR_COUNT = 1    # set global count to 1
   MR_COUNT = 2      # set local count to 2
end
puts MR_COUNT        # this is the global constant
puts Foo::MR_COUNT   # this is the local "Foo" constant

Second Example

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

Vorrang der Ruby-Operatoren

In der folgenden Tabelle sind alle Operatoren von der höchsten bis zur niedrigsten Priorität aufgeführt.

Methode	Operator	Beschreibung
Ja	:: ::	Operator mit konstanter Auflösung
Ja	[] [] =	Elementreferenz, Elementsatz
Ja	** **.	Potenzierung (zur Macht erheben)
Ja	! ~ + -	Nicht, Komplement, unäres Plus und Minus (Methodennamen für die letzten beiden sind + @ und - @)
Ja	* /%	Multiplizieren, dividieren und modulo
Ja	+ -	Addition und Subtraktion
Ja	>> <<	Bitweise Verschiebung nach rechts und links
Ja	&	Bitweises 'UND'
Ja	^ |	Bitweises exklusives ODER und reguläres ODER
Ja	<= <>> =	Vergleichsoperatoren
Ja	<=> == ===! = = ~! ~	Gleichheits- und Musterübereinstimmungsoperatoren (! = Und! ~ Können möglicherweise nicht als Methoden definiert werden)
	&&	Logisches 'UND'
	||	Logisches 'ODER'
	.. ...	Reichweite (inklusive und exklusiv)
	? ::	Ternäres Wenn-Dann-Sonst
	=% = {/ = - = + = | = & = >> = << = * = && = || = ** =	Zuordnung
	definiert?	Überprüfen Sie, ob das angegebene Symbol definiert ist
	nicht	Logische Negation
	oder und	Logische Komposition

NOTE- Operatoren mit einem Ja in der Methodenspalte sind tatsächlich Methoden und können daher überschrieben werden.