Je faisais référence au guide de programmation Swift d'Apple pour comprendre la création d'objets mutables / immuables (Array, Dictionary, Sets, Data) en langage Swift. Mais je ne pouvais pas comprendre comment créer des collections immuables dans Swift.

Je voudrais voir les équivalents dans Swift pour ce qui suit dans Objective-C

Réseau immuable

NSArray *imArray = [[NSArray alloc]initWithObjects:@"First",@"Second",@"Third",nil];

Réseau mutable

NSMutableArray *mArray = [[NSMutableArray alloc]initWithObjects:@"First",@"Second",@"Third",nil];
[mArray addObject:@"Fourth"];

Dictionnaire immuable

NSDictionary *imDictionary = [[NSDictionary alloc] initWithObjectsAndKeys:@"Value1", @"Key1", @"Value2", @"Key2", nil];

Dictionnaire mutable

NSMutableDictionary *mDictionary = [[NSMutableDictionary alloc]initWithObjectsAndKeys:@"Value1", @"Key1", @"Value2", @"Key2", nil];
[mDictionary setObject:@"Value3" forKey:@"Key3"];

Tableaux

Créer un tableau immuable

Première manière:

let array = NSArray(array: ["First","Second","Third"])

Deuxième manière:

let array = ["First","Second","Third"]

Créer un tableau mutable

var array = ["First","Second","Third"]

Ajouter un objet au tableau

array.append("Forth")

Dictionnaires

Créer un dictionnaire immuable

let dictionary = ["Item 1": "description", "Item 2": "description"]

Créer un dictionnaire mutable

var dictionary = ["Item 1": "description", "Item 2": "description"]

Ajouter une nouvelle paire au dictionnaire

dictionary["Item 3"] = "description"

_{Plus d'informations sur Apple Developer}

Swift n'a aucune baisse de remplacement pour NSArrayou les autres classes de collection en Objective-C.

Il existe des classes de tableaux et de dictionnaires, mais il convient de noter que ce sont des types «valeur», comparés à NSArray et NSDictionary qui sont des types «objet».

La différence est subtile mais peut être très importante pour éviter les bogues de cas de pointe.

Dans Swift, vous créez un tableau "immuable" avec:

let hello = ["a", "b", "c"]

Et un tableau "mutable" avec:

var hello = ["a", "b", "c"]

Les tableaux mutables peuvent être modifiés comme NSMutableArray:

var myArray = ["a", "b", "c"]

myArray.append("d") // ["a", "b", "c", "d"]

Cependant, vous ne pouvez pas passer un tableau mutable à une fonction:

var myArray = ["a", "b", "c"]

func addToArray(myArray: [String]) {
  myArray.append("d") // compile error
}

Mais le code ci-dessus fonctionne avec un NSMutableArray:

var myArray = ["a", "b", "c"] as NSMutableArray

func addToArray(myArray: NSMutableArray) {
  myArray.addObject("d")
}

addToArray(myArray)

myArray // ["a", "b", "c", "d"]

Vous pouvez obtenir NSMutableArrayle comportement de en utilisant un inoutparamètre de méthode:

var myArray = ["a", "b", "c"]

func addToArray(inout myArray: [String]) {
  myArray.append("d")
}

addToArray(&myArray)

myArray // ["a", "b", "c", "d"]

Réécrit cette réponse 2015-08-10 pour refléter le comportement actuel de Swift.

Il n'y a qu'un Arrayet un seul Dictionarytype dans Swift. La mutabilité dépend de la façon dont vous la construisez:

var mutableArray = [1,2,3]
let immutableArray = [1,2,3]

c'est-à-dire que si vous créez une assignation à une variable, elle est modifiable, alors que si vous créez une assignation à une constante, elle ne l'est pas.

AVERTISSEMENT: les baies immuables ne sont pas entièrement immuables! Vous pouvez toujours modifier leur contenu, mais pas leur longueur totale!

Déclarez simplement votre (tout) objet ou variable avec

'let' key word -> for "constan/Immutable" array, dictionary, variable, object..etc.

et

'var' key word -> for "Mutable" array, dictionary, variable, object..etc. 

Pour plus d'informations

«Utilisez let pour créer une constante et var pour créer une variable. La valeur d'une constante n'a pas besoin d'être connue au moment de la compilation, mais vous devez lui attribuer une valeur exactement une fois. Cela signifie que vous pouvez utiliser des constantes pour nommer une valeur que vous déterminez une fois mais que vous utilisez à plusieurs endroits. "

var myVariable = 42
myVariable = 50
let myConstant = 42

Lisez «Le langage de programmation Swift».

Si vous voulez travailler avec Array(Swift) comme avec NSArray, vous pouvez utiliser une simple fonction de pont. Exemple:

var arr1 : Array = []

arr1.bridgeToObjectiveC().count

Cela fonctionne de la même manière pour let.

À partir de la documentation d'Apple:

Mutabilité des collections

Si vous créez un tableau, un ensemble ou un dictionnaire et que vous l'assignez à une variable, la collection créée sera modifiable. Cela signifie que vous pouvez modifier (ou muter) la collection après sa création en ajoutant, supprimant ou modifiant des éléments dans la collection. Inversement, si vous affectez un tableau, un ensemble ou un dictionnaire à une constante, cette collection est immuable et sa taille et son contenu ne peuvent pas être modifiés.

https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/CollectionTypes.html#//apple_ref/doc/uid/TP40014097-CH8-ID105

D'autres utilisations des collections immuables / mutables dépendent de la raison pour laquelle vous voulez qu'elles soient mutables / immuables. Les collections sont des types de valeur dans Swift, ce qui signifie que leur contenu est copié lorsqu'ils sont affectés à une autre valeur ou transmis à une autre fonction / méthode. Par conséquent, vous n'avez pas à vous soucier de savoir si une fonction de méthode de réception peut modifier le tableau d'origine. Par conséquent, vous n'avez pas besoin de vous assurer de renvoyer une collection immuable si votre classe contient une collection mutable, par exemple.

[Non modifiable et immuable]

Le tableau de Swift peut être mis en sourdine

[let vs var, valeur vs type de référence]

Collection immuable ^{[À propos]} - est une structure de collection dont ne peut pas être modifiée. Cela signifie que vous ne pouvez pas ajouter, supprimer, modifier après la création

let + struct(comme Array, Set, Dictionary) est plus apte à être immuable

Il existe quelques classes (par exemple NSArray ) qui ne fournissent pas d'interface pour changer l'état interne

mais

class A {
    var value = "a"
}

func testMutability() {
    //given
    let a = A()
    
    let immutableArr1 = NSArray(array: [a])
    let immutableArr2 = [a]
    
    //when
    a.value = "aa"
    
    //then
    XCTAssertEqual("aa", (immutableArr1[0] as! A).value)
    XCTAssertEqual("aa", immutableArr2[0].value)
}   

Ce serait plutôt un unmodifiabletableau