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

===不是相等运算符!

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为假

更多示例请点击这里

我将在这里大量引用Object文档，因为我认为它有一些很好的解释。我鼓励你阅读它，还有这些方法的文档，因为它们在其他类中被重写了，比如String。

旁注:如果你想自己在不同的对象上尝试这些，可以使用这样的东西:

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}

== -一般的"平等"

在Object级别，==仅当obj和other是同一个对象时才返回true。通常，这个方法在子类中被重写，以提供特定于类的含义。

这是最常见的比较，因此也是您(作为类的作者)决定两个对象是否“相等”的最基本的地方。

=== - case相等

对于Object类，实际上与调用#==相同，但通常由后代重写，以在case语句中提供有意义的语义。

这是非常有用的。有趣的===实现的例子:

范围 正则表达式 Proc(在Ruby 1.9中)

所以你可以这样做:

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

这里有一个简洁的例子，说明case+Regex如何使代码更简洁。当然，通过提供您自己的===实现，您可以获得自定义大小写语义。

eql吗?-哈希等价

eql吗?如果obj和other指向相同的散列键，则方法返回true。Hash使用它来测试成员是否相等。对于Object类的对象，eql?是==的同义词。子类通常通过别名eql?它们被重写的==方法，但也有例外。例如，数值类型跨==执行类型转换，但不跨eql?,所以: 1 == 1.0 #=> true 1. eql ?1.0 #=> false

因此，您可以自由地为自己的用途覆盖它，或者您可以覆盖==并使用别名:eql?:==所以这两个方法的行为是相同的。

等于多少?-身份比较

不像==，相等?方法永远不应该被子类覆盖:它用于确定对象的身份(即a.equal?(b)如果a与b是相同的对象)。

这是有效的指针比较。

=== #——大小写相等

== #——一般相等

两者的工作原理类似，但“===”甚至可以执行case语句

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

区别就在这里

String === "test"   #=> true
String == "test"  #=> 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)

我喜欢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