var myArray1 : [String] = ["1","2","3","4","5"]
var myArray2 : [String] = ["1","5"]
// 1) Comparing 2 simple arrays
if(myArray1 == myArray2) {
println("Equality")
} else {
println("Equality no")
}
// -> prints equality -> thanks god
// 2) comparing to a "copy" of an array
// swift copies arrays when passed as parameters (as per doc)
func arrayTest(anArray: [String]) -> Bool {
return anArray == myArray1
}
println("Array test 1 is \(arrayTest(myArray1))")
println("Array test 2 is \(arrayTest(myArray2))")
// equality works for both
myArray2.append("test")
println("Array test 2 is \(arrayTest(myArray2))")
// false (obvIoUsly)
myArray2.removeAtIndex(5)
println("Array test 2 is \(arrayTest(myArray2))")
// true
苹果说，在阵列副本的幕后有优化。看起来像有时 – 不总是 – 结构实际上是否复制。
也就是说，
1)是==迭代所有的数组，以执行基于元素的比较？ (看起来像)
– >那么在非常大的数组上的性能/内存使用情况如何呢？
2)如果所有元素相等，我们确定==将永远返回true吗？我有坏的回忆==在Java字符串
3)有一种方法来检查myArray1和myArray2在技术上是否使用相同的“内存位置”/指针等等？我理解如何优化工作和潜在的警告。
谢谢。
struct NeverEqual: Equatable { }
func ==(lhs: NeverEqual,rhs: NeverEqual)->Bool { return false }
let x = [NeverEqual()]
var y = x
x == y // this returns true
[NeverEqual()] == [NeverEqual()] // false
x == [NeverEqual()] // false
let z = [NeverEqual()]
x == z // false
x == y // true
y[0] = NeverEqual()
x == y // now false
为什么？ Swift数组不符合Equatable，但它们有一个==运算符，在标准库中定义为：
func ==<T : Equatable>(lhs: [T],rhs: [T]) -> Bool
此运算符循环遍历lhs和rhs中的元素，比较每个位置的值。它不做位比较 – 它调用每对元素的==运算符。这意味着如果你为你的元素写一个custom ==，它会被调用。
但它包含一个优化 – 如果两个数组的底层缓冲区是相同的，它不会打扰，它只是返回true(它们包含相同的元素，当然是相等的！)。
这个问题完全是NeverEqual等式运算符的错误。平等应该是传递的，对称的和反身的，这一个不是反射的(x == x是假的)。但它仍然可以抓住你unawares。
Swift数组是copy-on-write – 所以当你写var x = y时，它实际上并不是数组的副本，它只是把x的存储缓冲区指针指向y。只有当x或y稍后被变异时，它才会创建缓冲区的副本，以使未更改的变量不受影响。这对于数组的行为类似于值类型，但仍然是高性能的。
在早期版本的Swift中，你实际上可以在数组上调用===(同样在早期版本中，变异行为有点不同，如果你改变x，y也会改变，即使它已经声明为let – 出来，所以他们改变了)。
你可以重现一个旧的行为===数组与此(非常依赖于实现依赖，除非是戳和刺探调查)诀窍：
let a = [1,2,3]
var b = a
a.withUnsafeBufferPointer { outer in
b.withUnsafeBufferPointer { inner in
println(inner.baseAddress == outer.baseAddress)
}
}
