Swift reference vs value with arrays and dictionaries - arrays

Question

In a nutshell,
I create an object consisting of an Integer and an Array of Strings.
I put something into both the integer and the array
I put the object into a dictionary
I get a new reference to the object and attempt to append to the array. This is where it fails
//: Playground - noun: a place where people can play
class IdAndArray {
var id: Int = 0
var stringArray:[String] = [String]()
}
var dict:[Int:IdAndArray] = [Int:IdAndArray]()
var testRec = IdAndArray()
testRec.id = 1
testRec.stringArray.append("1 line")
dict[56] = testRec
var ref = (dict[56]?.stringArray)!
print(ref.count) // 1
ref.append("2 line")
var anotherRef = (dict[56]?.stringArray)!
print(anotherRef.count) // 1 instead of 2???
I suspect this may be related to this:
Implementing a multimap in Swift with Arrays and Dictionaries
I also suspect it is something to do with optionals but I am forcing the unwrap with the !
For the record, I'm coming from a java background.

Answer 1

Swift arrays and dictionaries are value types. When you assign one that is in a variable to another variable, you are making a copy of the original.
So when you do this:
var ref = (dict[56]?.stringArray)!
ref is an entirely new copy of the array and not the one that is in the dictionary, so modifying it has no effect on the original copy in the dictionary.
If instead you had done:
dict[56]?.stringArray.append("2 line")
then you would have modified the copy that is in the dictionary.
Note: In reality, Swift doesn't make a copy of the array until you modify one of the copies. This is done behind the scenes to avoid unnecessary copying and to keep things quick. The copy logically happens immediately when you assign it, but you wouldn't notice the difference until you start modifying one of the copies, so Swift delays the copy until it matters.
Now consider this change to your code:
var ref = dict[56]!
print(ref.stringArray.count) // 1
ref.stringArray.append("2 line")
var anotherRef = dict[56]!
print(anotherRef.stringArray.count) // 2 this time!!!
Here, ref points to an instance of a class which is a reference type. In this case, both ref and anotherRef point to the same object, and thus you are modifying the array in the dictionary this time.