Ruby公开了处理相等的几种不同方法:

a.equal?(b) # object identity - a and b refer to the same object

a.eql?(b) # object equivalence - a and b have the same value

a == b # object equivalence - a and b have the same value with type conversion.

点击下面的链接继续阅读，它给了我一个清晰的总结理解。

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

希望它能帮助别人。

Ruby公开了处理相等的几种不同方法:

a.equal?(b) # object identity - a and b refer to the same object

a.eql?(b) # object equivalence - a and b have the same value

a == b # object equivalence - a and b have the same value with type conversion.

点击下面的链接继续阅读，它给了我一个清晰的总结理解。

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

希望它能帮助别人。

我想扩展一下===运算符。

===不是相等运算符!

Not.

让我们把这一点讲清楚。

在Javascript和PHP中，===可能是一个相等操作符，但在Ruby中，这不是一个相等操作符，并且具有根本不同的语义。

那么===是做什么的呢?

===是模式匹配操作符!

===匹配正则表达式 ===检查范围成员关系 ===检查是否是类的实例 ===调用lambda表达式 ===有时可以检查是否相等，但大多数情况下不能

那么，这种疯狂是怎么说得通的呢?

可枚举#grep在内部使用=== 语句内部使用===的情况 有趣的是，救援在内部使用===

这就是为什么在语句中可以使用正则表达式、类和范围，甚至lambda表达式。

一些例子

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

所有这些示例都可以使用pattern === value以及grep方法。

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]

.eql吗?—如果接收方和实参具有相同类型且值相等，则此操作符返回true。

例如- 10.eql?(10.0)为假值。

=== -它将在case语句中测试是否相等。

例如-(1…10)=== 1为真

== -该操作符检查两个给定的操作数是否相等。如果等于，则返回TRUE，否则返回FALSE。

例如-(1…10)== 1为假

更多示例请点击这里

我喜欢jtband的答案，但因为它太长了，我将添加我自己的紧凑答案:

==， ===， eql?,等于多少? 是四个比较器，即。Ruby中比较两个对象的4种方法。 在Ruby中，所有比较器(和大多数操作符)实际上都是方法调用，因此您可以自己更改、覆盖和定义这些比较方法的语义。然而，重要的是要理解，当Ruby的内部语言构造使用哪个比较器:

==(价值比较) Ruby在任何地方都使用:==来比较两个对象的值，例如。散列值:

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

===(案例比较) Ruby在case/when结构中使用:===。下面的代码段在逻辑上是相同的:

case foo
  when bar;  p 'do something'
end

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

eql吗?(散列值的比较) Ruby使用:eql?(结合哈希方法)来比较哈希键。在大多数类中:eql?与:==相同。 关于:eql?只有当你想创建自己的特殊类时才重要:

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

注意:常用的ruby类集也依赖于哈希键比较。

等于多少?(对象身份比较) Ruby使用:equal?来检查两个对象是否相同。(BasicObject类的)这个方法不应该被覆盖。

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

我编写了一个简单的测试。

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)