Compare arrays in swift

by

You’re right to be slightly nervous about ==:

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

Why? Swift arrays do not conform to Equatable, but they do have an == operator, defined in the standard library as:

func ==<T : Equatable>(lhs: [T], rhs: [T]) -> Bool

This operator loops over the elements in lhs and rhs, comparing the values at each position. It does not do a bitwise compare – it calls the == operator on each pair of elements. That means if you write a custom == for your element, it’ll get called.

But it contains an optimization – if the underlying buffers for the two arrays are the same, it doesn’t bother, it just returns true (they contain identical elements, of course they’re equal!).

This issue is entirely the fault of the NeverEqual equality operator. Equality should be transitive, symmetric and reflexive, and this one isn’t reflexive (x == x is false). But it could still catch you unawares.

Swift arrays are copy-on-write – so when you write var x = y it doesn’t actually make a copy of the array, it just points x’s storage buffer pointer at y’s. Only if x or y are mutated later does it then make a copy of the buffer, so that the unchanged variable is unaffected. This is critical for arrays to behave like value types but still be performant.

In early versions of Swift, you actually could call === on arrays (also in early versions, the mutating behaviour was a bit different, if you mutated x, y would also change even though it had been declared with let – which freaked people out so they changed it).

You can kinda reproduce the old behaviour of === on arrays with this (very implementation-dependent not to be relied-on except for poking and prodding investigations) trick:

let a = [1,2,3]
var b = a

a.withUnsafeBufferPointer { outer in 
    b.withUnsafeBufferPointer { inner in 
        println(inner.baseAddress == outer.baseAddress) 
    } 
}

More Related Contents:

  1. Convert Dictionary to Array in swift
  2. Swift how to sort array of custom objects by property value
  3. How to check if an element is in an array
  4. Removing duplicate elements from an array in Swift
  5. How to sort an array of custom objects by property value in Swift
  6. How to iterate a loop with index and element in Swift
  7. How do I concatenate or merge arrays in Swift?
  8. Pick a random element from an array
  9. Sort Objects in Array by date
  10. How do I insert an element at the correct position into a sorted array in Swift?
  11. Shorthand to test if an object exists in an array for Swift?
  12. Swift JSONDecode decoding arrays fails if single element decoding fails
  13. How do I sort a swift array containing instances of NSManagedObject subclass by an attribute value (date)
  14. Flatten [Any] Array Swift
  15. How to remove an element from an array in Swift
  16. Swift: Pass array by reference?
  17. Is it possible to make an Array extension in Swift that is restricted to one class?
  18. How do you create an immutable array in Swift?
  19. Compare values of two arrays – classic asp
  20. Swift 4 JSON Codable – value returned is sometimes an object, others an array
  21. Reorder array compared to another array in Swift [duplicate]
  22. swift: modifying arrays inside dictionaries
  23. How can I convert an array to a tuple?
  24. How to stable sort an array in swift?
  25. New Array from Index Range Swift
  26. Iterate over two arrays simultaneously
  27. Why does the reverse() function in the Swift standard library return ReverseRandomAccessCollection?
  28. Compare 2 arrays and list the differences – Swift
  29. In Swift how can I sort one array based on another array?
  30. check if all elements of an array have the same value in Swift

Leave a Comment