equal?、eql?、=== 和 == 之间有什么区别？

Question

我试图理解这四种方法之间的区别。我知道默认情况下 == 调用方法 equal? 当两个操作数引用完全相同的对象时该方法返回 true。

=== 默认情况下也会调用 == ，后者调用 equal?...好吧，所以如果这三个方法都没有被重写，那么我猜 ===、== 和 equal? 做的事情完全相同吗？

现在出现了eql?。这是做什么的（默认情况下）？它是否调用操作数的哈希/ID？

为什么 Ruby 有这么多等号？它们在语义上应该有所不同吗？

Answer 1

相等运算符：== 和 !=

== 运算符也称为相等或双重相等，如果两个对象相等则返回 true，否则返回 false。

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

!= 运算符也称为不等式，与 == 相反。如果两个对象不相等，则返回 true；如果相等，则返回 false。

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

请注意，具有相同元素但顺序不同的两个数组不相等，同一字母的大写和小写版本不相等等等。

当比较不同类型的数字（例如整数和浮点数）时，如果它们的数值相同，==将返回true。

2 == 2.0 # Output: => true

平等的？

与测试两个操作数是否相等的 == 运算符不同，equal 方法检查两个操作数是否引用同一个对象。这是 Ruby 中最严格的平等形式。

例子：
一个=“禅宗”
b = "zen"

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

a.equal? b  # Output: => false

在上面的示例中，我们有两个具有相同值的字符串。但是，它们是两个不同的对象，具有不同的对象 ID。那么，平等呢？方法将返回 false。

我们再试一次，只是这次 b 将成为对 a 的引用。请注意，两个变量的对象 ID 相同，因为它们指向同一个对象。

a = "zen"
b = a

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

a.equal? b  # Output: => true

情商？

在 Hash 类中，eql?方法用于测试键是否相等。需要一些背景知识来解释这一点。在一般的计算环境中，哈希函数接受任意大小的字符串（或文件）并生成固定大小的字符串或整数，称为哈希码，通常称为唯一哈希。一些常用的哈希码类型包括 MD5、SHA-1 和 CRC。它们用于加密算法、数据库索引、文件完整性检查等。一些编程语言（例如Ruby）提供称为哈希表的集合类型。哈希表是类似字典的集合，成对存储数据，由唯一键及其对应的值组成。在底层，这些密钥存储为哈希码。哈希表通常简称为哈希。请注意“哈希”一词如何指代哈希码或哈希表。在 Ruby 编程的上下文中，哈希这个词几乎总是指类似字典的集合。

Ruby 提供了一个名为 hash 的内置方法来生成哈希码。在下面的示例中，它接受一个字符串并返回一个哈希码。请注意，具有相同值的字符串始终具有相同的哈希码，即使它们是不同的对象（具有不同的对象 ID）。

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

hash 方法在 Kernel 模块中实现，包含在 Object 类中，该类是所有 Ruby 对象的默认根。一些类（例如 Symbol 和 Integer）使用默认实现，其他类（例如 String 和 Hash）提供自己的实现。

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

在 Ruby 中，当我们将某些内容存储在哈希（集合）中时，作为键提供的对象（例如字符串或符号）将被转换为哈希码并存储。稍后，当从哈希（集合）中检索元素时，我们提供一个对象作为键，该对象被转换为哈希码并与现有键进行比较。如果匹配，则返回相应项的值。使用 eql? 进行比较方法在幕后。

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

在大多数情况下，eql?方法的行为与 == 方法类似。然而，也有一些例外。例如，eql?将整数与浮点数进行比较时，不执行隐式类型转换。

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

大小写相等运算符：===

许多 Ruby 的内置类（例如 String、Range 和 Regexp）都提供了自己的 === 运算符实现，也称为大小写相等、三重等于或三等式。由于它在每个类中的实现方式不同，因此根据调用它的对象类型，它的行为也会有所不同。一般来说，如果右侧的对象“属于”左侧的对象或“是其成员”，则返回 true。例如，它可用于测试对象是否是类（或其子类之一）的实例。

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

使用可能最适合该工作的其他方法也可以实现相同的结果。通常最好是在不牺牲效率和简洁性的情况下，尽可能明确地编写易于阅读的代码。

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

请注意，最后一个示例返回 false，因为诸如 2 之类的整数是 Fixnum 类的实例，而 Fixnum 类是 Integer 类的子类。 ===，is_a？和instance_of？如果对象是给定类或任何子类的实例，方法将返回 true。 instance_of 方法更严格，仅当对象是该确切类的实例而不是子类时才返回 true。

is_a?和种类？方法在 Kernel 模块中实现，并由 Object 类混合。两者都是同一方法的别名。让我们验证一下：

Kernel.instance_method(:kind_of?) == Kernel.instance_method(:is_a?) # 输出：=>; true

Range === 的实现

当对 range 对象调用 === 运算符时，如果右侧的值落在左侧的范围内，则返回 true。

(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

请记住， === 运算符调用左侧对象的 === 方法。因此 (1..4) === 3 等价于 (1..4).=== 3。换句话说，左侧操作数的类将定义 === 方法的实现被调用，因此操作数位置不可互换。

=== 的 Regexp 实现

如果右侧的字符串与左侧的正则表达式匹配，则返回 true。
/zen/ === "今天练习坐禅" # 输出： =>真的
# 与
"practice zazen Today"=~ /zen/

在 case/when 语句上隐式使用 === 运算符

该运算符也在 case/when 语句的幕后使用。这是它最常见的用途。

minutes = 15

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

# Output: match

在上面的示例中，如果 Ruby 隐式使用了双等号运算符 (==)，则范围 10..20 将不会被视为等于整数，例如 15。它们匹配是因为三等号运算符 (===) 是在所有 case/when 语句中隐式使用。上面示例中的代码相当于：

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

模式匹配运算符：=~ 和 !~

=~（等代号）和 !~（bang-代号）运算符用于将字符串和符号与正则表达式模式进行匹配。

String 和 Symbol 类中 =~ 方法的实现需要一个正则表达式（Regexp 类的实例）作为参数。

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

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

Regexp 类中的实现需要一个字符串或符号作为参数。

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

在所有实现中，当字符串或符号与正则表达式模式匹配时，它返回一个整数，即匹配的位置（索引）。如果没有匹配，则返回 nil。请记住，在 Ruby 中，任何整数值都是“真”，而 nil 是“假”，因此 =~ 运算符可以在 if 语句和三元运算符中使用。

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

模式匹配运算符对于编写较短的 if 语句也很有用。示例：

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

!~ 运算符与 =~ 相反，如果不匹配则返回 true，如果匹配则返回 false。

如需了解更多信息，请访问此博文。

Answer 2

我想扩展 === 运算符。

=== 不是相等运算符！

不是。

让我们真正了解这一点。

您可能熟悉 === 作为 Javascript 和 PHP 中的相等运算符，但这并不是 Ruby 中的相等运算符，并且具有根本不同的语义。

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

=== 是模式匹配运算符！

• === 匹配正则表达式
• === 检查范围成员资格
• === 检查是否是类的实例
• === 调用 lambda 表达式
• === 有时会检查相等性，但大多数情况下不会

那么这种疯狂的行为有什么意义呢？

• Enumerable#grep 在内部使用 ===
• case when 语句在内部使用 ===
• 有趣的事实，rescue 在内部使用 ===

这就是为什么您可以在 case when 语句中使用正则表达式、类和范围，甚至 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]

Answer 3

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

希望对其他人有帮助。

Answer 4

=== #---case equals

== #--- generic equals

两者的工作原理相似，但“===”甚至 case 语句

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

这里是区别

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

Answer 5

1. .eql？ - 如果接收者和参数具有相同的类型和相等的值，则此运算符返回 true。

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

2. === - 它将测试 case 语句中的相等性。

例如 - (1...10) === 1 is true

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

例如 - (1...10) == 1 为 false

了解更多示例 点击此处

Answer 6

我为上述所有内容编写了一个简单的测试。

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)

Answer 7

我将在这里大量引用对象文档 ，因为我认为它有一些很好的解释。我鼓励您阅读它，以及这些方法的文档，因为它们在其他类中被覆盖，例如 字符串。

旁注：如果您想在不同的对象上亲自尝试这些，请使用如下内容：

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}

---

== — 通用“相等”

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

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

=== — 大小写相等

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

这非常有用。具有有趣的 === 实现的示例：

• Range
• Regex
• 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 可以使代码更加简洁。当然，通过提供您自己的 === 实现，您可以获得自定义 case 语义。

eql? — 哈希 相等性

如果 obj 和 other 引用相同的哈希键，eql? 方法将返回 true。 Hash 使用它来测试成员的相等性。 对于Object类的对象，eql?与==同义。子类通常通过别名< code>eql? 到其重写的 == 方法，但也有例外。例如，Numeric 类型可以跨 == 执行类型转换，但不能跨 eql? 执行类型转换，因此：

<前><代码>1 == 1.0 #=>真的
1.eql? 1.0#=>错误的

因此您可以随意覆盖此设置供您自己使用，或者您可以覆盖 == 并使用 alias :eql? :== 所以这两个方法的行为方式相同。

equal? — 身份比较

与 == 不同，equal? 方法永远不应该被子类重写：它用于确定对象标识（即 a.equal? (b) 当且仅当 a 与 b 是同一对象）。

这实际上是指针比较。

Answer 8

我喜欢 jtbandes 答案，但由于它很长，我将添加我自己的紧凑答案：

==, ===, eql?< /code>,等于？
是 4 个比较器，即在 Ruby 中比较 2 个对象的 4 种方法。
由于在 Ruby 中，所有比较器（以及大多数运算符）实际上都是方法调用，因此您可以自己更改、覆盖和定义这些比较方法的语义。然而，重要的是要了解，Ruby 的内部语言构造何时使用哪个比较器：

==（值比较）
Ruby 在任何地方都使用 :== 来比较 2 个对象的值，例如。哈希值：

{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