平等？，eql ?, ===和==有什么区别？

2018-06-20 20:29:30

我想了解这四种方法之间的区别。我知道默认==调用方法equal? 当两个操作数引用完全相同的对象时，它将返回true。

===默认情况下也调用equal?调用== equal? ...好吧，如果所有这三种方法都没有被覆盖，那么我猜=== ， ==和equal? 做同样的事情？

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

为什么Ruby有这么多的平等标志？他们是否应该在语义上有所不同？

我将在这里大量引用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。通常，这个方法在后代类中被覆盖以提供类特定的含义。

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

`===` - 病例平等

对于类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如何使代码更加清晰。当然，通过提供您自己的===实现，您可以获得自定义case语义。

`eql?` - `Hash`平等

eql? 方法返回true如果obj和other引用相同的散列键。 Hash使用它来测试成员是否相等。 对于Object类的Object ， eql? 与==同义。 子类通常通过别名eql?来继承这个传统eql? 到他们重写的==方法，但也有例外。例如， Numeric类型通过==执行类型转换，但不跨eql? ，所以：

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

所以你可以自由地覆盖这个为你自己的用途，或者你可以覆盖==和使用alias :eql? :== alias :eql? :==所以这两个方法的行为方式相同。

`equal?` - 身份比较

不像== ， equal? 方法不应该被子类覆盖：它用于确定对象标识（即a.equal?(b)如果a与b相同）。

这是有效的指针比较。

我爱jtbandes的答案，但由于它很长，我会添加我自己的紧凑答案：

== ， === ， eql? ， equal?
是4个比较器，即。在Ruby中比较两个对象的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类Set也依赖于哈希键比较。

equal? （对象身份比较）
Ruby使用：平等吗？检查两个对象是否相同。这个方法（类BasicObject）不应该被覆盖。

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

平等操作符：==和！=

==运算符（也称为equals或double equal）将在两个对象相等时返回true，否则返回false。

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

！=运算符AKA不等式或bang-tilde与==相反。如果两个对象不相等，它将返回true，如果两个对象相等，则返回false。

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

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

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

2 == 2.0 # Output: => true

等于？

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

例如：a =“禅”b =“禅”

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

a.equal? b  # Output: => false

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

让我们再试一次，只有这个时候b会是一个参考。请注意，两个变量的对象ID都相同，因为它们指向相同的对象。

a = "zen"
b = a

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

a.equal? b  # Output: => true

EQL？

在Hash类中，eql？它用于测试键是否相等。需要一些背景来解释这一点。在计算的一般环境中，散列函数采用任意大小的字符串（或文件）并生成称为散列码的固定大小的字符串或整数，通常称为散列。一些常用的散列码类型是MD5，SHA-1和CRC。它们用于加密算法，数据库索引，文件完整性检查等。一些编程语言（如Ruby）提供了一种称为散列表的集合类型。散列表是类似字典的集合，它们成对存储数据，由唯一键和它们的相应值组成。在引擎盖下，这些键被存储为散列码。散列表通常被称为散列。注意hashcan这个词是指一个哈希码还是一个哈希表。在Ruby编程中，单词hash几乎总是指类似字典的集合。

Ruby提供了一种称为哈希的内置方法来生成哈希码。在下面的例子中，它需要一个字符串并返回一个哈希码。注意具有相同值的字符串总是具有相同的哈希码，尽管它们是不同的对象（具有不同的对象ID）。

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

散列方法在包含在Object类中的Kernel模块中实现，该类是所有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？在将整数与float进行比较时，不会执行隐式类型转换。

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

案例相等运算符：===

许多Ruby的内置类（如String，Range和Regexp）提供了===运算符的自己实现，也称为case-equality，triple equals或threequals。因为它在每个类中的实现方式不同，所以它的行为将有所不同，具体取决于所调用对象的类型。通常，如果右侧的对象“属于”或“是左侧的对象的成员”，则返回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类的实例，它是Integer类的一个子类。 ===，is_a？和instance_of？如果对象是给定类或任何子类的实例，则方法返回true。 instance_of方法更严格，只有当对象是该类的实例时才返回true，而不是子类。

is_a？和kind_of？方法在内核模块中实现，该模块由Object类混合。两者都是相同方法的别名。我们来验证一下：

Kernel.instance_method（：kind_of？）== Kernel.instance_method（：is_a？）＃输出：=> true

===的范围实现

在范围对象上调用===运算符时，如果右侧的值落在左侧的范围内，则返回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.换句话说，左边操作数的类将定义===方法的实现是称为，所以操作数位置不可互换。

正则表达式实现===

如果右侧的字符串与左侧的正则表达式匹配，则返回true。 / zen / ===“今日练习zazen”＃输出：=> true＃与“今日练习zazen”=〜/ 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。它们匹配是因为三等号运算符（===）是隐含地用于所有情况/当语句。上例中的代码等同于：

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

模式匹配运算符：=〜和！〜

使用=〜（等于波浪号）和！〜（bang-tilde）运算符来针对正则表达式模式来匹配字符串和符号。

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

在所有实现中，当字符串或符号与Regexp模式匹配时，它会返回一个整数，该整数是匹配的位置（索引）。如果没有匹配，则返回nil。请记住，在Ruby中，任何整数值都是“truthy”，nil是“falsy”，所以=〜运算符可用于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。

更多信息可在此博客文章中找到。

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

上一篇: What's the difference between equal?, eql?, ===, and ==?

下一篇: Use === in php if statement