julia - Julia中“==”和“===”比较运算符有什么区别？

Question

Julia中的==和===比较运算符有什么区别？

Answer 1

@ChrisRackauckas的答案就目前而言是准确的-即对于可变对象。但是，这个问题还有很多，所以在这里我将详细说明。

===运算符（is函数的别名）实现Henry Baker的EGAL谓词[1，2]：当两个对象在程序上无法区分时，x === y为true –即，您无法编写演示任何内容的代码。 x和y之间的差异。这归结为以下规则：


对于可变值（数组，可变复合类型），===检查对象身份：如果x === y和x是同一对象，并且存储在内存中的同一位置，则y为true。
对于不可变的复合类型，如果x === y和x具有相同的类型（因此具有相同的结构）且其对应的组件都是递归地y，则===为true。
对于位类型（不可更改的数据块，如Int或Float64），如果x === y和x包含完全相同的位，则y为true。


这些规则（递归应用）定义了===的行为。

另一方面，==函数是用户可定义的，并且实现了“抽象值相等”。超载能力是一个主要区别：


===不可重载-它是具有固定的预定义行为的内置函数。您不能扩展或更改其行为。
==是可重载的-它是具有infix语法的常规（对于Julia）通用函数。它具有后备定义，可以为用户定义的类型提供有用的默认行为，但是您可以通过为类型添加新的更具体的方法到==来更改它的显示状态。


要提供有关==对于内置类型的行为以及当人们扩展它时对于用户定义类型的行为的更多详细信息，请参见the docs：


例如，所有数字类型均按数字值进行比较，而忽略
类型。将字符串作为字符序列进行比较，忽略
编码。


您可以将其视为“直觉平等”。如果两个数字在数值上相等，则它们为==：

julia> 1 == 1.0 == 1 + 0im == 1.0 + 0.0im == 1//1
true

julia> 0.5 == 1/2 == 1//2
true

但是请注意， ==实现精确的数值相等：

julia> 2/3 == 2//3
false

这些值是不相等的，因为 2/3是浮点值 0.6666666666666666，它是最接近 Float64的数学值2/3（对于有理数，用 2//3表示为Julia表示），但是 不完全等于2/3。此外， 0.6666666666666666


遵循IEEE 754语义的浮点数。


这包括一些可能意外的属性：


有明显的正和负浮点零（ ==和 0.0）：它们是 -0.0，即使它们的行为不同，因此也不是 ==。
有许多不同的非数字（ ===）值：它们本身，彼此或任何其他值都不是 NaN；它们各自是 ==自身，但彼此不是 ===，因为它们具有不同的位。


例子：

julia> 0.0 === -0.0
false

julia> 0.0 == -0.0
true

julia> 1/0.0
Inf

julia> 1/-0.0
-Inf

julia> NaN === NaN
true

julia> NaN === -NaN
false

julia> -NaN === -NaN
true

julia> NaN == NaN
false

julia> NaN == -NaN
false

julia> NaN == 1.0
false

这有点令人困惑，但这就是IEEE标准。

此外， !==的文档还指出：


集合通常应通过对所有内容递归调用 ==来实现 ==。


因此， ==给出的值相等的概念递归地扩展到集合：

julia> [1, 2, 3] == [1, 2, 3]
true

julia> [1, 2, 3] == [1.0, 2.0, 3.0]
true

julia> [1, 2, 3] == Any[1//1, 2.0, 3 + 0im]
true

因此，这继承了标量 ==比较的缺点：

julia> a = [1, NaN, 3]
3-element Array{Float64,1}:
   1.0
 NaN
   3.0

julia> a == a
false

另一方面， ==比较总是测试对象的身份，因此，即使两个数组具有相同的类型并包含相同的值，它们也只有在相同的数组时才相等：

julia> b = copy(a)
3-element Array{Float64,1}:
   1.0
 NaN
   3.0

julia> a === a
true

julia> a === b
false

julia> b === b
true

===和 a不是 b的原因是，即使它们当前恰好在此处包含相同的数据，由于它们是可变的并且不是相同的对象，因此您可以对其中之一进行突变，然后它将变为显然它们是不同的：

julia> a[1] = -1
-1

julia> a # different than before
3-element Array{Int64,1}:
 -1
  2
  3

julia> b # still the same as before
3-element Array{Int64,1}:
 1
 2
 3

因此，您可以通过突变告诉 ===和 a是不同的对象。相同的逻辑不适用于不可变的对象：如果它们包含相同的数据，则只要它们具有相同的值，它们就无法区分。因此，不可变值不受绑定到特定位置的约束，这是编译器能够如此有效地优化不可变值使用的原因之一。

也可以看看：


Get rid of Julia's `WARNING: redifining constant` for strings that are not changed?