dans Swift: Différence entre la Matrice de VS NSArray VS [AnyObject]

Array est un struct, donc c'est un type de valeur en Swift.
NSArray est immuable Objective C classe, donc c'est un type de référence rapide et il est relié à Array<AnyObject>.
NSMutableArray est la mutable sous-classe de NSArray.

var arr : NSMutableArray = ["Pencil", "Eraser", "Notebook"]
var barr = ["Pencil", "Eraser", "Notebook"]

func foo (var a : Array<String>)
{
    a[2] = "Pen"
}

func bar (a : NSMutableArray)
{
    a[2] = "Pen"
}

foo(barr)
bar(arr)

println (arr)
println (barr)

Imprime:

(
    Pencil,
    Eraser,
    Pen
)
[Pencil, Eraser, Notebook]

Parce que foo les changements de la valeur locale de a et bar modifications de la référence.
Il fonctionne également si vous ne let arr au lieu de var comme avec d'autres types de référence.

À l'aide de la Krzak réponse, voici un exemple concret:

//Let´s create an Array as a struct showing alternative ways
    var arrStruct = ["Pencil", "Eraser", "Notebook"]
    //or var arrStruct: [String] = ["Pencil", "Eraser", "Notebook"]
    //or var arrStruct: Array = ["Pencil", "Eraser", "Notebook"]
    //or var arrStruct = Array(["Pencil", "Eraser", "Notebook"])
    //All this alternative ways create an array as struct

    //Now let´s create a function that modifies this array struct
    func modifyArr(alternativeArr: [String]) 
    //or func modify(alternativeArr: Array<String>)
    {
        alternativeArr[2] = "Pen" //compilation error
        //This won´t work. In swift >= 3.0 all func parametes are a let variable, 
        //this means alternativeArr is defined as a let. What one has to do is 
        //create a local variable and copy the value.

        var localAlternativeArr = alternativeArr
        //or var localAlternativeArr: [String] = alternativeArr
        //or var localAlternativeArr: Array = alternativeArr

        //now we can change it.
        localAlternativeArr[2] = "Pen"
        print(localAlternativeArr) //["Pencil", "Eraser", "Pen"]
        print(alternativeArr) //["Pencil", "Eraser", "Notebook"]
    }

    modifyArr(alternativeArr: arrStruct)
    print(arrStruct) //["Pencil", "Eraser", "Notebook"]

    //Since the arrStruct is a struct every time we assign to another variable or 
    //pass it as a func argument a copy is made.



//Now let´s create as an NSMutableArray
    var arrClass: NSMutableArray = ["Pencil", "Eraser", "Notebook"]
    //or var arrStruct = NSMutableArray(array: ["Pencil", "Eraser", "Notebook"])
    //All this create an NSMutableArray as a class

    //Now let´s create a function that modifies this array struct
    func modifyArr(alternativeArr: NSMutableArray)
    {
        alternativeArr[2] = "Pen"
        print(alternativeArr)
        //(
        //  Pencil,
        //  Eraser,
        //  Pen
        //)
    }

    modifyArr(alternativeArr: arrClass)
    print(arrClass)
    //(
    //  Pencil,
    //  Eraser,
    //  Pen
    //)

    //Since the arrClass is a class everytime we assign to another variable or 
    //pass it as a func argument is passed by reference. Means that any change
    //inside modifyArr is going to change the arrClass outside. The change 
    // is made in the same pointer.