What's the difference between equal?, eql?, ===, and ==?

I am trying to understand the difference between these four methods. I know by default that == calls the method equal? which returns true when both operands refer to exactly the same object.

=== by default also calls == which calls equal? ... okay, so if all these three methods are not overridden, then I guess === , == and equal? do exactly the same thing?

Now comes eql? . What does this do (by default)? Does it make a call to the operand's hash/id?

Why does Ruby have so many equality signs? Are they supposed to differ in semantics?


I'm going to heavily quote the Object documentation here, because I think it has some great explanations. I encourage you to read it, and also the documentation for these methods as they're overridden in other classes, like String.

Side note: if you want to try these out for yourself on different objects, use something like this:

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 "equality"

At the Object level, == returns true only if obj and other are the same object. Typically, this method is overridden in descendant classes to provide class-specific meaning.

This is the most common comparison, and thus the most fundamental place where you (as the author of a class) get to decide if two objects are "equal" or not.

=== — case equality

For class Object, effectively the same as calling #== , but typically overridden by descendants to provide meaningful semantics in case statements.

This is incredibly useful. Examples of things which have interesting === implementations:

  • Range
  • Regex
  • Proc (in Ruby 1.9)
  • So you can do things like:

    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
    

    See my answer here for a neat example of how case + Regex can make code a lot cleaner. And of course, by providing your own === implementation, you can get custom case semantics.

    eql?Hash equality

    The eql? method returns true if obj and other refer to the same hash key. This is used by Hash to test members for equality. For objects of class Object , eql? is synonymous with == . Subclasses normally continue this tradition by aliasing eql? to their overridden == method, but there are exceptions. Numeric types, for example, perform type conversion across == , but not across eql? , so:

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

    So you're free to override this for your own uses, or you can override == and use alias :eql? :== alias :eql? :== so the two methods behave the same way.

    equal? — identity comparison

    Unlike == , the equal? method should never be overridden by subclasses: it is used to determine object identity (that is, a.equal?(b) if a is the same object as b ).

    This is effectively pointer comparison.


    I love jtbandes answer, but since it is pretty long, I will add my own compact answer:

    == , === , eql? , equal?
    are 4 comparators, ie. 4 ways to compare 2 objects, in Ruby.
    As, in Ruby, all comparators (and most operators) are actually method-calls, you can change, overwrite, and define the semantics of these comparing methods yourself. However, it is important to understand, when Ruby's internal language constructs use which comparator:

    == (value comparison)
    Ruby uses :== everywhere to compare the values of 2 objects, eg. Hash-values:

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

    === (case comparison)
    Ruby uses :=== in case/when constructs. The following code snippets are logically identical:

    case foo
      when bar;  p 'do something'
    end
    
    if bar === foo
      p 'do something'
    end
    

    eql? (Hash-key comparison)
    Ruby uses :eql? (in combination with the method hash) to compare Hash-keys. In most classes :eql? is identical with :==.
    Knowledge about :eql? is only important, when you want to create your own special classes:

    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
    

    Note: The commonly used Ruby-class Set also relies on Hash-key-comparison.

    equal? (object identity comparison)
    Ruby uses :equal? to check if two objects are identical. This method (of class BasicObject) is not supposed to be overwritten.

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

    Equality operators: == and !=

    The == operator, also known as equality or double equal, will return true if both objects are equal and false if they are not.

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

    The != operator, AKA inequality or bang-tilde, is the opposite of ==. It will return true if both objects are not equal and false if they are equal.

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

    Note that two arrays with the same elements in a different order are not equal, uppercase and lowercase versions of the same letter are not equal and so on.

    When comparing numbers of different types (eg, integer and float), if their numeric value is the same, == will return true.

    2 == 2.0 # Output: => true
    

    equal?

    Unlike the == operator which tests if both operands are equal, the equal method checks if the two operands refer to the same object. This is the strictest form of equality in Ruby.

    Example: a = "zen" b = "zen"

    a.object_id  # Output: => 20139460
    b.object_id  # Output :=> 19972120
    
    a.equal? b  # Output: => false
    

    In the example above, we have two strings with the same value. However, they are two distinct objects, with different object IDs. Hence, the equal? method will return false.

    Let's try again, only this time b will be a reference to a. Notice that the object ID is the same for both variables, as they point to the same object.

    a = "zen"
    b = a
    
    a.object_id  # Output: => 18637360
    b.object_id  # Output: => 18637360
    
    a.equal? b  # Output: => true
    

    eql?

    In the Hash class, the eql? method it is used to test keys for equality. Some background is required to explain this. In the general context of computing, a hash function takes a string (or a file) of any size and generates a string or integer of fixed size called hashcode, commonly referred to as only hash. Some commonly used hashcode types are MD5, SHA-1, and CRC. They are used in encryption algorithms, database indexing, file integrity checking, etc. Some programming languages, such as Ruby, provide a collection type called hash table. Hash tables are dictionary-like collections which store data in pairs, consisting of unique keys and their corresponding values. Under the hood, those keys are stored as hashcodes. Hash tables are commonly referred to as just hashes. Notice how the word hashcan refer to a hashcode or to a hash table. In the context of Ruby programming, the word hash almost always refers to the dictionary-like collection.

    Ruby provides a built-in method called hash for generating hashcodes. In the example below, it takes a string and returns a hashcode. Notice how strings with the same value always have the same hashcode, even though they are distinct objects (with different object IDs).

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

    The hash method is implemented in the Kernel module, included in the Object class, which is the default root of all Ruby objects. Some classes such as Symbol and Integer use the default implementation, others like String and Hash provide their own implementations.

    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, when we store something in a hash (collection), the object provided as a key (eg, string or symbol) is converted into and stored as a hashcode. Later, when retrieving an element from the hash (collection), we provide an object as a key, which is converted into a hashcode and compared to the existing keys. If there is a match, the value of the corresponding item is returned. The comparison is made using the eql? method under the hood.

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

    In most cases, the eql? method behaves similarly to the == method. However, there are a few exceptions. For instance, eql? does not perform implicit type conversion when comparing an integer to a float.

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

    Case equality operator: ===

    Many of Ruby's built-in classes, such as String, Range, and Regexp, provide their own implementations of the === operator, also known as case-equality, triple equals or threequals. Because it's implemented differently in each class, it will behave differently depending on the type of object it was called on. Generally, it returns true if the object on the right "belongs to" or "is a member of" the object on the left. For instance, it can be used to test if an object is an instance of a class (or one of its subclasses).

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

    The same result can be achieved with other methods which are probably best suited for the job. It's usually better to write code that is easy to read by being as explicit as possible, without sacrificing efficiency and conciseness.

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

    Notice the last example returned false because integers such as 2 are instances of the Fixnum class, which is a subclass of the Integer class. The ===, is_a? and instance_of? methods return true if the object is an instance of the given class or any subclasses. The instance_of method is stricter and only returns true if the object is an instance of that exact class, not a subclass.

    The is_a? and kind_of? methods are implemented in the Kernel module, which is mixed in by the Object class. Both are aliases to the same method. Let's verify:

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

    Range Implementation of ===

    When the === operator is called on a range object, it returns true if the value on the right falls within the range on the left.

    (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
    

    Remember that the === operator invokes the === method of the left-hand object. So (1..4) === 3 is equivalent to (1..4).=== 3. In other words, the class of the left-hand operand will define which implementation of the === method will be called, so the operand positions are not interchangeable.

    Regexp Implementation of ===

    Returns true if the string on the right matches the regular expression on the left. /zen/ === "practice zazen today" # Output: => true # is the same as "practice zazen today"=~ /zen/

    Implicit usage of the === operator on case/when statements

    This operator is also used under the hood on case/when statements. That is its most common use.

    minutes = 15
    
    case minutes
      when 10..20
        puts "match"
      else
        puts "no match"
    end
    
    # Output: match
    

    In the example above, if Ruby had implicitly used the double equal operator (==), the range 10..20 would not be considered equal to an integer such as 15. They match because the triple equal operator (===) is implicitly used in all case/when statements. The code in the example above is equivalent to:

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

    Pattern matching operators: =~ and !~

    The =~ (equal-tilde) and !~ (bang-tilde) operators are used to match strings and symbols against regex patterns.

    The implementation of the =~ method in the String and Symbol classes expects a regular expression (an instance of the Regexp class) as an argument.

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

    The implementation in the Regexp class expects a string or a symbol as an argument.

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

    In all implementations, when the string or symbol matches the Regexp pattern, it returns an integer which is the position (index) of the match. If there is no match, it returns nil. Remember that, in Ruby, any integer value is "truthy" and nil is "falsy", so the =~ operator can be used in if statements and ternary operators.

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

    Pattern-matching operators are also useful for writing shorter if statements. Example:

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

    The !~ operator is the opposite of =~, it returns true when there is no match and false if there is a match.

    More info is available at this blog post.

    链接地址: http://www.djcxy.com/p/58610.html

    上一篇: '是'操作员意外地表现为非

    下一篇: 平等?,eql ?, ===和==有什么区别?