使用和等於

有三個相等運算子：==，=== 和 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

因為儘管 1 和 1.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

這可能起初看起來令人驚訝！ 該程式如何區分兩個向量 A 和 B？因為向量是可變的，它可以修改 A，然後它的行為與 B 不同。但無論它如何修改 A，A 將始終與 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 觀察到。因此，沒有辦法區分 A 和 C 之間的區別，因此它們是相等的。

什麼時候使用 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