Was ist der Unterschied zwischen gleich ?, eql ?, === und ==?

Ich versuche zu verstehen, den Unterschied zwischen diesen vier Methoden. Ich weiß, standardmäßig, dass == ruft die Methode equal? was gibt true zurück, wenn beide Operanden beziehen sich auf genau das gleiche Objekt.

=== standardmäßig auch Anrufe == fordert equal?... okay, also, wenn alle diese drei Methoden werden nicht überschrieben, denke ich mal
===== und equal? genau das tun die gleiche Sache?

Nun kommt eql?. Was hat das zu tun (standardmäßig)? Macht es einen Aufruf an die Operanden-hash/id?

Warum Ruby so viele Geschlechter Schildern? Sollen Sie unterscheiden sich in Semantik?

InformationsquelleAutor der Frage denniss | 2011-08-23

  1. 701

    Werde ich stark quote die Objekt-Dokumentation hier, weil ich denke, es hat einige gute Erklärungen. Ich ermutige Sie, es zu Lesen, und auch die Dokumentation für diese Methoden, wie Sie sind überschrieben, die in anderen Klassen, wie Zeichenfolge.

    Seite Hinweis: wenn Sie möchten, um zu versuchen, diese für sich selbst auf verschiedene Objekte, verwenden Sie so etwas wie dieses:

    class Object
  def all_equals(o)
    ops = [:==, :===, :eql?, :equal?]
    Hash[ops.map(&:to_s).zip(ops.map {|s| send(s, o) })]
  end
end

"a".all_equals "a" # => {"=="=>true, "==="=>true, "eql?"=>true, "equal?"=>false}

    == — generic "Gleichheit"

    Auf der Objekt-Ebene == gibt true zurück, nur wenn obj und other sind das gleiche Objekt. In der Regel wird diese Methode in abgeleiteten Klassen überschrieben zu bieten-Klasse-spezifische Bedeutung.

    Dies ist der häufigste Vergleich und damit die grundlegendsten Ort, wo Sie (wie der Autor einer Klasse) bekommen, um zu entscheiden, ob zwei Objekte "gleich" sind oder nicht.

    === — Fall Gleichheit

    Für die Klasse Objekt, die effektiv das gleiche wie der Aufruf #==aber in der Regel überschrieben, durch die Nachkommen, um sinnvolle Semantik in case-Anweisungen.

    Dies ist unglaublich nützlich. Beispiele für Dinge, die interessant === Implementierungen:

    • Bereich
    • Regex
    • Proc (in Ruby 1.9)

    Also können Sie Sachen wie tun:

    case some_object
when /a regex/
  # The regex matches
when 2..4
  # some_object is in the range 2..4
when lambda {|x| some_crazy_custom_predicate }
  # the lambda returned true
end

    Sehen meine Antwort hier für ein ordentliches Beispiel dafür, wie case+Regex machen kann code viel sauberer. Und natürlich, indem Sie Ihre eigenen === Umsetzung, können Sie benutzerdefinierte case Semantik.

    eql? — Hash Gleichheit

    Den eql? Methode gibt true zurück, wenn obj und other beziehen sich auf den gleichen hash-Schlüssel. Diese wird von Hash zu test-Mitglieder für die Gleichstellung. Für Objekte der Klasse Objecteql? ist gleichbedeutend mit ==. Unterklassen der Regel setzen diese tradition Fort durch aliasing eql? Ihren überschrieben == Methode, aber es gibt Ausnahmen. Numeric Arten, zum Beispiel, führen Sie Typ-Konvertierung über ==aber nicht über eql? so:

    1 == 1.0     #=> true
1.eql? 1.0   #=> false

    So dass Sie frei sind, überschreiben Sie diese für Ihre eigenen Verwendungszwecke, oder Sie außer Kraft setzen können == und verwenden alias :eql? :== so, dass die beiden Methoden die gleiche Weise Verhalten.

    equal? — Identität, Vergleich

    Im Gegensatz zu ==die equal? Methode sollte nie von Unterklassen überschrieben: es wird verwendet, um zu bestimmen, Objekt-Identität (a.equal?(b) wenn a ist das gleiche Objekt wie b).

    Dies ist effektiv pointer-Vergleich.

    InformationsquelleAutor der Antwort jtbandes

  2. 36

    Ich Liebe jtbandes Antwort, aber da es ist ziemlich lang, ich will hinzufügen, meine eigene kompakte Antwort:

    =====eql?equal?

    4 Komparatoren, dh. 4 Möglichkeiten, um zu vergleichen 2 Objekte in Ruby.

    Wie in Ruby, alle Komparatoren (und die Betreiber) sind eigentlich Methode-Anrufe können Sie ändern, überschreiben und definieren die Semantik dieser Vergleich der Methoden selbst. Es ist jedoch wichtig zu verstehen, wenn Ruby ' s interne Sprachkonstrukte verwenden Sie die Komparator:

    == (Wert-Vergleich)

    Ruby verwendet :== überall zu vergleichen, die Werte von 2 Objekten, zB. Hash-Werte:

    {a: 'z'}  ==  {a: 'Z'}    # => false
{a: 1}    ==  {a: 1.0}    # => true

    === (Fall-Vergleich)

    Ruby verwendet :=== in case/when-Konstrukte. Die folgenden code-snippets sind logisch identisch:

    case foo
  when bar;  p 'do something'
end

if bar === foo
  p 'do something'
end

    eql? (Hash-key comparison)

    Ruby verwendet :eql? (in Kombination mit der Methode hash) zum vergleichen von Hash-Schlüsseln. In den meisten Klassen :eql? ist identisch mit :==.

    Kenntnisse über :eql? ist nur dann wichtig, wenn Sie möchten, erstellen Sie Ihre eigenen speziellen Klassen:

    class Equ
  attr_accessor :val
  alias_method  :initialize, :val=
  def hash()           self.val % 2             end
  def eql?(other)      self.hash == other.hash  end
end

h = {Equ.new(3) => 3,  Equ.new(8) => 8,  Equ.new(15) => 15}    #3 entries, but 2 are :eql?
h.size            # => 2
h[Equ.new(27)]    # => 15

    Hinweis: Der Häufig verwendete Ruby-Klasse Satz stützt sich auch auf die Hash-Schlüssel-Vergleich.

    equal? (Objekt-id-Vergleich)

    Ruby verwendet :gleich? um zu überprüfen, ob zwei Objekte identisch sind. Diese Methode (der Klasse BasicObject) soll nicht überschrieben werden.

    obj = obj2 = 'a'
obj.equal? obj2       # => true
obj.equal? obj.dup    # => false

    InformationsquelleAutor der Antwort Andreas Rayo Kniep

  3. 22

    Gleichheitsoperatoren: == und !=

    Den = = - operator, auch bekannt als Geschlechter-oder Doppelzimmer gleich, wird true zurückgegeben, wenn beide Objekte gleich sind und false, wenn Sie nicht sind.

    "koan" == "koan" # Output: => true

    Den != Betreiber, AKA Ungleichheit oder bang-tilde, ist das Gegenteil von ==. Es gibt true zurück, wenn beide Objekte nicht gleich sind und false, wenn Sie gleich sind.

    "koan" != "discursive thought" # Output: => true

    Beachten Sie, dass zwei arrays mit der gleichen Elemente in einer anderen Reihenfolge sind nicht gleich -, groß-und Kleinbuchstaben Versionen des gleichen Buchstaben sind nicht gleich und so weiter.

    Beim Vergleich von zahlen unterschiedlicher Typen (z.B. integer und float), wenn Ihr numerischer Wert ist der gleiche, == true zurück.

    2 == 2.0 # Output: => true

    gleich?

    Im Gegensatz zum == operator, die testet, ob beide Operanden gleich sind, die gleiche Methode prüft, ob die beiden Operanden auf das gleiche Objekt beziehen. Dies ist die strengste form der Gleichheit in Ruby.

    Beispiel:
    a = "zen"
    b = "zen"

    a.object_id  # Output: => 20139460
b.object_id  # Output :=> 19972120

a.equal? b  # Output: => false

    In dem obigen Beispiel, wir haben zwei Saiten mit dem gleichen Wert. Jedoch sind Sie zwei unterschiedliche Objekte mit unterschiedlichen Objekt-IDs. Daher, der gleich? Methode den Wert false zurück.

    Lassen Sie uns versuchen Sie es erneut, nur dieses mal ist b eine Referenz auf einen. Beachten Sie, dass die Objekt-ID ist die gleiche für beide Variablen, wie Sie auf das gleiche Objekt zeigen.

    a = "zen"
b = a

a.object_id  # Output: => 18637360
b.object_id  # Output: => 18637360

a.equal? b  # Output: => true

    eql?

    In der Hash-Klasse, die eql? Methode es wird verwendet, um test-keys für die Gleichstellung. Einige hintergrund-erforderlich ist, dies zu erklären. Im Allgemeinen Kontext von computing, eine hash-Funktion nimmt einen string (oder eine Datei) in jeder Größe und erzeugt eine Zeichenkette oder ein integer mit fester Größe namens hashcode, die gemeinhin als nur Hasch. Einige Häufig verwendete hashcode Arten sind MD5, SHA-1 und CRC. Sie sind bei der Verschlüsselung verwendet algorithmen, Datenbank-Indizierung, file integrity checking, etc. Einige Programmiersprachen, wie beispielsweise Ruby, bieten eine Sammlung Typ, genannt hash-Tabelle. Hash-Tabellen sind dictionary-ähnliche Sammlungen, die für die Speicherung von Daten in Paaren, bestehend aus eindeutigen Schlüssel und Ihre entsprechenden Werte. Unter der Haube, diese Schlüssel gespeichert werden, hashcodes. Hash-Tabellen sind gemeinhin nur als hashes. Beachten Sie, wie das Wort hashcan beziehen sich auf ein hashcode oder eine hash-Tabelle. Im Kontext von Ruby Programmierung, das Wort hash-fast immer bezieht sich auf das Wörterbuch wie Sammlung.

    Ruby bietet eine integrierte Methode genannt hash für die Erzeugung von hashcodes. Im Beispiel unten, es nimmt einen string und liefert einen hashcode. Beachten Sie, wie strings mit dem gleichen Wert haben immer den selben hashcode, auch wenn Sie unterschiedliche Objekte (mit verschiedenen Objekt-IDs).

    "meditation".hash  # Output: => 1396080688894079547
"meditation".hash  # Output: => 1396080688894079547
"meditation".hash  # Output: => 1396080688894079547

    Die hash-Methode ist implementiert in dem Kernel-Modul, enthalten in der Object-Klasse, die die Standard-root für alle Ruby-Objekte. Einige Klassen wie Symbol-und Integer-verwenden Sie die Standard-Implementierung, andere wie String-und Hash-eigene Implementierungen. 

    Symbol.instance_method(:hash).owner  # Output: => Kernel
Integer.instance_method(:hash).owner # Output: => Kernel

String.instance_method(:hash).owner  # Output: => String
Hash.instance_method(:hash).owner  # Output: => Hash

    In Ruby, wenn wir etwas lagern in einem hash (Sammlung), das Objekt als Schlüssel (z.B. string oder symbol) umgewandelt und gespeichert, als ein hashcode. Später, beim abrufen eines Elements aus dem hash (Inkasso) bieten wir ein Objekt wie einen Schlüssel, der ist, umgewandelt in einen hashcode und im Vergleich zu den vorhandenen keys. Wenn es eine übereinstimmung gibt, wird der Wert der entsprechende Eintrag zurückgegeben. Der Vergleich wird mithilfe der eql? Methode unter der Haube. 

    "zen".eql? "zen"    # Output: => true
# is the same as
"zen".hash == "zen".hash # Output: => true

    In den meisten Fällen, die eql? die Methode verhält sich ähnlich wie die == Methode. Es gibt jedoch ein paar Ausnahmen. Zum Beispiel, eql? führt keine implizite Typkonvertierung beim Vergleich von integer in float.

    2 == 2.0    # Output: => true
2.eql? 2.0    # Output: => false
2.hash == 2.0.hash  # Output: => false

    Fall Gleichheit, operator: ===

    Viele von Ruby ' s eingebaute Klassen wie String -, Reichweiten-und Regexp, eigene Implementierungen der operator===, auch bekannt als Fall-Gleichheit, dreifach gleich oder threequals. Weil es anders implementiert in jeder Klasse, es verhält sich unterschiedlich, je nach Typ von Objekt es aufgerufen wurde. In der Regel, es gibt true zurück, wenn das Objekt auf der rechten Seite "gehört" oder "ist Mitglied von" das Objekt auf der linken Seite. Zum Beispiel, es kann verwendet werden, um zu testen, ob ein Objekt eine Instanz einer Klasse (oder einer Ihrer Unterklassen).

    String === "zen"  # Output: => true
Range === (1..2)   # Output: => true
Array === [1,2,3]   # Output: => true
Integer === 2   # Output: => true

    Das gleiche Ergebnis kann erzielt werden mit anderen Methoden, die sind wahrscheinlich am besten geeignet für den job. Meistens ist es besser, code zu schreiben, der leicht zu Lesen, indem Sie so informativ wie möglich, ohne Einbußen bei der Effizienz und Prägnanz. 

    2.is_a? Integer   # Output: => true
2.kind_of? Integer  # Output: => true
2.instance_of? Integer # Output: => false

    Bemerken das Letzte Beispiel false zurück, weil die ganzen zahlen wie 2 sind Instanzen des Fixnum-Klasse, die eine Unterklasse der Integer-Klasse. Das ===, is_a? und instance_of? Methoden gibt true zurück, wenn das Objekt einer Instanz der angegeben Klasse ist oder keine Unterklassen. Die instance_of Methode ist strenger und nur dann true zurück, wenn das Objekt eine Instanz des genauen Klasse keine Unterklasse.

    Den is_a? und kind_of? - Methoden implementiert, die in den Kernel-Modul, die gemischt in, die von der Object-Klasse. Beide sind Aliase auf die gleiche Methode. Lassen Sie uns überprüfen:

    Kernel.instance_method(:kind_of?) == Kernel.instance_method(:is_a?) # Ausgabe: => true

    Bereich Umsetzung ===

    Wenn der operator === wird aufgerufen, auf ein range-Objekt, es gibt true zurück, wenn der Wert auf der rechten Seite fällt in den Bereich auf der linken Seite.

    (1..4) === 3  # Output: => true
(1..4) === 2.345 # Output: => true
(1..4) === 6  # Output: => false

("a".."d") === "c" # Output: => true
("a".."d") === "e" # Output: => false

    Denken Sie daran, dass die = = = - operator ruft die = = = - Methode des linken Objekts. Also (1..4) === 3 entspricht (1..4).=== 3. In anderen Worten, die Klasse des linken Operanden wird festgelegt, welche Umsetzung von den = = = - Methode aufgerufen, so wird der operand Positionen sind nicht austauschbar.

    Regexp-Implementierung ===

    Gibt true zurück, wenn der string auf der rechten Seite passt der reguläre Ausdruck auf der linken Seite.
    /zen/=== "die Praxis des zazen heute" # Output: => true
    # ist das gleiche wie
    "zazen üben heute"=~ /zen/

    Implizite Verwendung des = = = - operator auf den Fall/wenn-Anweisungen

    Dieser operator ist auch unter der Haube auf den Fall/wenn-Anweisungen. Das ist seine häufigste Verwendung.

    minutes = 15

case minutes
  when 10..20
    puts "match"
  else
    puts "no match"
end

# Output: match

    In dem obigen Beispiel, wenn Ruby hatte implizit verwendet das Doppel-gleich-operator (==), Bereich 10..20 würde nicht als gleich um eine ganze Zahl wie 15. Sie passen, weil der triple-gleich-operator (===) ist implizit in allen Fall/wenn-Anweisungen. Der code im Beispiel oben ist äquivalent zu:

    if (10..20) === minutes
  puts "match"
else
  puts "no match"
end

    Pattern-matching-Operatoren =~ und !~

    = ~ (Gleich-tilde) und !~ (bang-tilde), Operatoren werden verwendet, um Zeichenketten und Symbole gegen regex-Muster.

    Die Umsetzung der = ~ - Methode in der String und Symbol-Klassen erwartet einen regulären Ausdruck (eine Instanz der Regexp-Klasse) als argument. 

    "practice zazen" =~ /zen/   # Output: => 11
"practice zazen" =~ /discursive thought/ # Output: => nil

:zazen =~ /zen/    # Output: => 2
:zazen =~ /discursive thought/  # Output: => nil

    Die Umsetzung der Regexp-Klasse erwartet einen string oder ein symbol als argument. 

    /zen/ =~ "practice zazen"  # Output: => 11
/zen/ =~ "discursive thought" # Output: => nil

    In allen Implementierungen, wenn die Zeichen oder Zeichenfolge entspricht der Regexp-Muster, es gibt eine Ganzzahl zurück, die die position (index) des Spiels. Wenn es keine übereinstimmung gibt, gibt es null. Denken Sie daran, dass, in Ruby, ein beliebiger integer-Wert ist "truthy" und nil "falsy", so der =~ operator in verwendet werden kann, wenn Aussagen und ternäre Operatoren.

    puts "yes" if "zazen" =~ /zen/ # Output: => yes
"zazen" =~ /zen/?"yes":"no" # Output: => yes

    Pattern-matching-Operatoren sind auch nützlich für das schreiben von kürzeren if-Anweisungen. Beispiel:

    if meditation_type == "zazen" || meditation_type == "shikantaza" || meditation_type == "kinhin"
  true
end
Can be rewritten as:
if meditation_type =~ /^(zazen|shikantaza|kinhin)$/
  true
end

    Den !~ Betreiber ist das Gegenteil von =~, es gibt true zurück, wenn keine übereinstimmung vorhanden ist, und false, wenn es eine übereinstimmung gibt.

    Mehr info ist erhältlich bei in diesem blog-post.

    InformationsquelleAutor der Antwort BrunoFacca

  4. 7

    === #---Fall der Gleichheit

    == #--- Allgemeine Gleichheit

    beide arbeiten ähnlich, aber "===" auch tun case-Anweisungen

    "test" == "test"  #=> true
"test" === "test" #=> true

    hier der Unterschied

    String === "test"   #=> true
String == "test"  #=> false

    InformationsquelleAutor der Antwort Kishore Mohan

  5. 6

    Ruby stellt verschiedene Methoden für den Umgang der Geschlechter:

    ein.gleich?(b) # - Objekt-id - a und b auf das gleiche Objekt beziehen

    ein.eql?(b) # Objekt-äquivalenz - a und b den gleichen Wert haben

    a == b # Objekt-äquivalenz - a und b haben den gleichen Wert mit der Konvertierung geben.

    Lesen Sie weiter indem Sie auf den link unten, es gab mir eine klare zusammengefasst Verständnis.

    https://www.relishapp.com/rspec/rspec-expectations/v/2-0/docs/matchers/equality-matchers

    Hoffe es hilft anderen.

    InformationsquelleAutor der Antwort kalibbala

  6. 3

    Ich würde gerne erweitern auf die === Betreiber.

    === ist nicht eine Gleichheit operator!

    Nicht.

    Let ' s get dass wirklich Punkt über.

    Könnten Sie vertraut sein mit === als Gleichheits-operator in Javascript und PHP, aber dies nicht nur ein Gleichheits-operator in Rubinrot und hat grundlegend andere Semantik.

    Also, was bedeutet === tun?

    === ist der pattern-matching-operator!

    • === passt auf regulären Ausdrücken
    • === überprüft Palette Mitgliedschaft
    • === Prüfungen als Instanz einer Klasse
    • === Anrufe lambda-Ausdrücke
    • === manchmal prüft Gleichheit, aber meistens ist es nicht

    Also, wie funktioniert dieser Wahnsinn Sinn?

    • Enumerable#grep verwendet === intern
    • case when Anweisungen verwenden === intern
    • Spaß Tatsache, rescue verwendet === intern

    Deshalb können Sie reguläre Ausdrücke verwenden und Klassen und Bereiche und auch lambda-Ausdrücke in einer case when - Anweisung.

    Einige Beispiele

    case value
when /regexp/
  # value matches this regexp
when 4..10
  # value is in range
when MyClass
  # value is an instance of class
when ->(value) { ... }
  # lambda expression returns true
when a, b, c, d
  # value matches one of a through d with `===`
when *array
  # value matches an element in array with `===`
when x
  # values is equal to x unless x is one of the above
end

    Alle diese Beispiel der Arbeit mit pattern === value auch mit grep Methode.

    arr = ['the', 'quick', 'brown', 'fox', 1, 1, 2, 3, 5, 8, 13]
arr.grep(/[qx]/)                                                                                                                            
# => ["quick", "fox"]
arr.grep(4..10)
# => [5, 8]
arr.grep(String)
# => ["the", "quick", "brown", "fox"]
arr.grep(1)
# => [1, 1]

    InformationsquelleAutor der Antwort akuhn

  7. -8

    Schrieb ich einen einfachen test für alle oben genannten.

    def eq(a, b)
  puts "#{[a, '==',  b]} : #{a == b}"
  puts "#{[a, '===', b]} : #{a === b}"
  puts "#{[a, '.eql?', b]} : #{a.eql?(b)}"
  puts "#{[a, '.equal?', b]} : #{a.equal?(b)}"
end

eq("all", "all")
eq(:all, :all)
eq(Object.new, Object.new)
eq(3, 3)
eq(1, 1.0)

    InformationsquelleAutor der Antwort Tom Phan

Schreibe einen Kommentar