Die Programmiersprache Ruby (German Edition)

wie das linke oder wenn es ein String ist, der denselben Text enthält. Beispiele:
(1..10) === 5 # true: 5 liegt im Bereich 1..10
/\d+/ === "123" # true: Der String entspricht dem regulären Ausdruck
String === "s" # true: "s" ist eine Instanz der Klasse String
:s === "s" # true in Ruby 1.9
    Es kommt selten vor, dass der Operator
===
auf diese Weise explizit verwendet wird. Viel häufiger wird er implizit in einer
case
-Anweisung verwendet.
    3.8.5.5 Der Operator =~
    Der Operator
=~
wird von
String
und
Regexp
(und von
Symbol
in Ruby 1.9) definiert, um Mustervergleiche durchzuführen, und ist eigentlich überhaupt kein Gleichheitsoperator. Er enthält jedoch ein Gleichheitszeichen, so dass er hier der Vollständigkeit halber angeführt wird.
Object
definiert eine Version von
=~
ohne Funktionalität, die stets
false
zurückgibt. Sie können diesen Operator in Ihrer eigenen Klasse definieren, wenn diese Klasse beispielsweise Mustervergleichsoperationen besitzt oder eine Art ungefährer Gleichheit unterstützt.
!~
ist als Negation von
=~
definiert. Es ist in Ruby 1.9 definierbar, aber nicht in Ruby 1.8.
    3.8.6 Objektreihenfolge
    So gut wie jede Klasse kann eine nützliche
==
-Methode definieren, um ihre Instanzen auf Gleichheit zu prüfen. Einige Klassen können auch eine Ordnungsrelation definieren. Das heißt: Für je zwei Instanzen einer solchen Klasse müssen die beiden Instanzen entweder gleich sein, oder eine Instanz muss »kleiner als« die andere sein. Zahlen sind das einleuchtendste Beispiel von Klassen, für die eine Ordnungsrelation sortiert ist. Strings sind ebenfalls geordnet, und zwar gemäß der numerischen Reihenfolge der Zeichencodes, aus denen die Strings bestehen. (Bei ASCII-Text handelt es sich um eine grob alphabetische Ordnungsrelation, die zwischen Groß- und Kleinschreibung unterscheidet.) Wenn eine Klasse eine Ordnungsrelation definiert, dann können Instanzen der Klasse verglichen und sortiert werden.
    In Ruby definieren Klassen eine Ordnungsrelation, indem sie den Operator
<=>
implementieren. Dieser Operator sollte
−1
zurückgeben, wenn sein linker Operand kleiner ist als als sein rechter,
0
, wenn die beiden Operanden gleich sind, und
1
, wenn der linke Operand größer ist als der rechte. Wenn die beiden Operanden nicht sinnvoll verglichen werden können (beispielsweise, wenn der rechte Operand einer anderen Klasse angehört), dann sollte der Operator
nil
zurückgeben:
1 <=> 5 # −1
5 <=> 5 # 0
9 <=> 5 # 1
"1" <=> 5 # nil: Integer und Strings sind nicht vergleichbar
    Der Operator
<=>
ist das Einzige, was zum Vergleichen von Werten benötigt wird. Aber er ist nicht sonderlich intuitiv. Deshalb importieren Klassen, die diesen Operator importieren, üblicherweise auch das Modul
Comparable
als Mixin. (Module und Mixins werden in „7.5.2 Module als Mixins“ behandelt.) Das Mixin
Comparable
definiert mithilfe von
<=>
folgende Operatoren:
    <
Kleiner als
<=
Kleiner oder gleich
==
Gleich
>=
Größer oder gleich
>
Größer als
    Comparable
definiert nicht den Operator
!=
; ihn definiert Ruby automatisch als Negation des Operators
==
. Zusätzlich zu diesen Vergleichsoperatoren definiert
Comparable
noch eine praktische Vergleichsmethode namens
between?
:
1.between?(0,10) # true: 0 <= 1 <= 10
    Wenn der Operator
<=> nil
zurückgibt, geben alle von ihm abgeleiteten Vergleichsoperatoren
false
zurück. Der spezielle
Float
-Wert
NaN
ist ein Beispiel:
nan = 0.0/0.0; # Null geteilt durch null ist keine Zahl
nan < 0 # false: Es ist nicht kleiner als null
nan > 0 # false: Es ist nicht größer als null
nan == 0 # false: Es ist nicht gleich null
nan == nan # false: Es ist nicht einmal identisch mit sich selbst!
nan.equal?(nan) # Dies ist natürlich true
    Beachten Sie, dass die Definition von
<=>
und der Import des Moduls
Comparable
einen
==
-Operator für Ihre Klasse definieren. Einige Klassen definieren ihren eigenen
==
-Operator – üblicherweise, wenn sie diesen effizienter implementieren können als eine auf
<=>
basierende Gleichheitsprüfung. Es ist möglich, Klassen zu definieren, die in ihren
==
- und
<=>
-Operatoren unterschiedliche Begriffe von Gleichheit implementieren. Beispielsweise könnte eine Klasse mit dem
==
-Operator String-Vergleiche durchführen, die zwischen Groß- und Kleinschreibung unterscheiden, mit
<=>
dagegen solche, die das nicht tun, so dass Instanzen der Klasse auf natürlichere Weise sortiert würden. Im Allgemeinen ist es jedoch am besten, wenn
<=>
dann (und nur