使用和等於

有三個相等運算子:=====isequal。 (最後一個不是真正的運算子,但它是一個函式,所有運算子都是函式。)

什麼時候使用 ==

==價值相等。當兩個物件在其當前狀態下表示相同的值時,它返回 true

例如,很明顯

julia> 1 == 1
true

但此外

julia> 1 == 1.0
true

julia> 1 == 1.0 + 0.0im
true

julia> 1 == 1//1
true

上面每個相等的右邊是不同的型別 ,但它們仍然代表相同的值。

對於可變物件,如陣列== 比較它們的現值。

julia> A = [1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> B = [1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> C = [1, 3, 2]
3-element Array{Int64,1}:
 1
 3
 2

julia> A == B
true

julia> A == C
false

julia> A[2], A[3] = A[3], A[2]  # swap 2nd and 3rd elements of A
(3,2)

julia> A
3-element Array{Int64,1}:
 1
 3
 2

julia> A == B
false

julia> A == C
true

大多數時候,== 是正確的選擇。

什麼時候使用 ===

===== 更嚴格的操作。它不是價值相等,而是衡量價值。如果兩個物件無法通過程式本身彼此區分,則它們是相等的。因此我們有

julia> 1 === 1
true

因為沒有辦法告訴 1 除了另一個 1。但

julia> 1 === 1.0
false

因為儘管 11.0 是相同的值,但它們的型別不同,因此程式可以區分它們。

此外,

julia> A = [1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> B = [1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> A === B
false

julia> A === A
true

這可能起初看起來令人驚訝! 該程式如何區分兩個向量 AB?因為向量是可變的,它可以修改 A,然後它的行為與 B 不同。但無論它如何修改 AA 將始終與 A 本身相同。因此,A 對於 A 來說是天生的,但對於 B 來說並不是真的。

繼續沿著這個脈絡,觀察

julia> C = A
3-element Array{Int64,1}:
 1
 2
 3

julia> A === C
true

通過將 A 分配給 C,我們說 C 已經別名 A。也就是說,它已成為 A 的另一個名稱。對 A 所做的任何修改也將由 C 觀察到。因此,沒有辦法區分 AC 之間的區別,因此它們是相等的。

什麼時候使用 isequal

==isequal 之間的區別非常微妙。最大的區別在於如何處理浮點數:

julia> NaN == NaN
false

這可能令人驚奇的結果是限定由用於浮點型別(IEEE-754)的 IEEE 標準。但是在某些情況下這沒有用,例如排序。isequal 是為這些情況提供的:

julia> isequal(NaN, NaN)
true

在光譜的另一面,== 將 IEEE 負零和正零視為相同的值(也是 IEEE-754 規定的)。然而,這些值在儲存器中具有不同的表示。

julia> 0.0
0.0

julia> -0.0
-0.0

julia> 0.0 == -0.0
true

再次出於分類目的,isequal 區分它們。

julia> isequal(0.0, -0.0)
false