==, gleich?, eql?, === in Ruby: was sie überprüfen und wann man sie verwenden sollte

29. Okt, 20:47 Uhr

3 Min. Lesezeit

Beitrags-Cover: ==, gleich?, eql?, === in Ruby: was sie überprüfen und wann man sie verwenden sollte

InhaltsverzeichnisKlicke auf den Link, um zur gewünschten Stelle zu navigieren

== (Überprüfung der Gleichheit von Werten)equal? (Überprüfung der Identität von Objekten)eql? (strenge Gleichheitsprüfung für Hashes und Zahlen)=== (case-match Operator)

Dieser Inhalt wurde automatisch aus dem Ukrainischen übersetzt.

Original ansehen

In Ruby gibt es mehrere Möglichkeiten zum Vergleichen. Sie sehen auf den ersten Blick ähnlich aus, funktionieren aber ganz anders.

== (Überprüfung der Gleichheit von Werten)

Überprüft, ob die Objekte denselben Inhalt haben.
Wird häufig in Klassen (String, Array, Hash) überschrieben, um Werte und nicht Identitäten zu vergleichen.

a = "hello"
b = "hello"

a == b        # => true
a.equal?(b)   # => false

== fragt: "Haben diese Objekte denselben Inhalt?"

equal? (Überprüfung der Identität von Objekten)

Überprüft, ob es dasselbe Objekt im Speicher ist.
Wird in Klassen nicht überschrieben, vergleicht immer die Objekt-IDs.

a = "hello"
b = "hello"
c = a

a.equal?(b)  # => false
a.equal?(c)  # => true

Hier muss man verstehen, was ein Objekt in Ruby ist.

eql? (strenge Gleichheitsprüfung für Hashes und Zahlen)

Überprüft Wert und Typ.
Wird hauptsächlich in Hashes für Schlüssel verwendet.

1 == 1.0     # => true
1.eql?(1.0)  # => false, da verschiedene Klassen (Integer vs Float)

eql? ist strenger als ==.

=== (case-match Operator)

Wird hauptsächlich in der case-Konstruktion verwendet (darüber sprechen wir gleich).
Verhält sich unterschiedlich für verschiedene Klassen:
- Bei Klassen (String, Integer) - überprüft, ob das Objekt zur Klasse gehört (is_a?).
- Bei regulären Ausdrücken - überprüft, ob der String dem Muster entspricht.
- Bei Range - ob das Objekt im Bereich liegt.

case 5
when 1..10
  "Im Bereich"   # => "Im Bereich"
end

String === "hello"  # => true
/ell/ === "hello"   # => true

Betrachten wir das Beispiel mit case etwas genauer. Wie funktioniert case … when in Ruby?

Syntax:

case Objekt
when Muster1
  Code1
when Muster2
  Code2
else
  Standard_Code
end

Was passiert im Hintergrund

Ruby macht ungefähr Folgendes:

if Muster1 === Objekt
  Code1
elsif Muster2 === Objekt
  Code2
else
  Standard_Code
end

Das heißt, when verwendet automatisch === für den Vergleich mit dem case-Wert.

Hier sind Beispiele für verschiedene Typen

Bereich (Range)

case 5
when 1..10
  "Im Bereich"
else
  "Außerhalb des Bereichs"
end
# => "Im Bereich"

Es funktioniert so, als ob Ruby (dies ist Pseudocode):

(1..10) === 5  # => true

Es ist jedoch wichtig zu beachten, dass die normale Verwendung von === mit Zahlen oder anderen Typen nicht unbedingt gleich funktioniert:

10 === (1..20)   # => false
10 == (1..20)    # => false
(1..20) == 10    # => false

Hier überprüft Range#===, ob die Zahl im Bereich liegt.

Klasse

case "hello"
when String
  "Das ist ein String"
when Integer
  "Das ist eine Zahl"
end
# => "Das ist ein String"

Ruby führt aus:

String === "hello"   # => true
Integer === "hello"  # => false

Für Klassen ist === eine Abkürzung für obj.is_a?(Klasse).

c) Regulärer Ausdruck

case "hello"
when /ell/
  "Übereinstimmung mit dem Muster"
else
  "Keine Übereinstimmung"
end
# => "Übereinstimmung mit dem Muster"

Im Hintergrund:

/ell/ === "hello"   # => true

Für Regexp überprüft ===, ob der String dem Muster entspricht.

Wir sind ein wenig vom Thema === abgekommen und haben uns mit case beschäftigt (weil dort === im Hintergrund verwendet wird). Ein so einfacher Operator, aber er macht verschiedene Dinge.

Um es sich leichter zu merken:

case x; when y - das ist nicht x == y, sondern y === x.
=== funktioniert unterschiedlich je nach Typ y:
- Class -> is_a?
- Range -> include?
- Regexp -> =~ (Übereinstimmung des Strings)

Das ermöglicht es, Bedingungen sehr flexibel zu schreiben.