Nawiązałem do przewodnika programowania Apple w języku Swift, aby zrozumieć tworzenie obiektów mutable / immutable (Array, Dictionary, Sets, Data) w języku Swift. Ale nie mogłem zrozumieć, jak stworzyć niezmienne kolekcje w Swift.

Chciałbym zobaczyć odpowiedniki w Swift dla poniższych w Objective-C

Niezmienna tablica

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

Mutable Array

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

Niezmienny słownik

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

Mutable Dictionary

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

Tablice

Utwórz niezmienną tablicę

Pierwszy sposób:

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

Drugi sposób:

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

Utwórz zmienną tablicę

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

Dołącz obiekt do tablicy

array.append("Forth")

Słowniki

Utwórz niezmienny słownik

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

Utwórz zmienny słownik

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

Dołącz nową parę do słownika

dictionary["Item 3"] = "description"

_{Więcej informacji na temat Apple Developer}

Swift nie ma żadnego zamiennika NSArrayani innych klas kolekcji w Objective-C.

Istnieją klasy tablicowe i słownikowe, ale należy zauważyć, że są to typy „wartości” w porównaniu do NSArray i NSDictionary, które są typami „obiektowymi”.

Różnica jest subtelna, ale może być bardzo ważna, aby uniknąć błędów związanych z krawędziami.

W swift tworzysz „niezmienną” tablicę zawierającą:

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

Oraz tablicę „zmienną” zawierającą:

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

Mutowalne tablice można modyfikować tak jak NSMutableArray:

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

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

Jednak nie możesz przekazać zmiennej tablicy do funkcji:

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

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

Ale powyższy kod działa z NSMutableArray:

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

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

addToArray(myArray)

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

Możesz osiągnąć NSMutableArrayzachowanie za pomocą inoutparametru metody:

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

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

addToArray(&myArray)

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

Ponownie napisałem tę odpowiedź 10.08.2015, aby odzwierciedlić obecne zachowanie Swift.

W Swift jest tylko Arrayjeden Dictionarytyp. Zmienność zależy od tego, jak ją skonstruujesz:

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

tj. jeśli utworzysz przypisanie do zmiennej, jest ona zmienna, podczas gdy jeśli utworzysz przypisanie do stałej, nie jest.

OSTRZEŻENIE: Niezmienne tablice nie są całkowicie niezmienne! Nadal możesz zmienić ich zawartość, ale nie całkowitą długość!

Po prostu zadeklaruj swój (dowolny) obiekt lub zmienną za pomocą

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

i

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

Aby uzyskać głębsze informacje

„Użyj let, aby utworzyć stałą i var, aby utworzyć zmienną. Wartość stałej nie musi być znana w czasie kompilacji, ale należy przypisać jej wartość dokładnie raz. Oznacza to, że możesz użyć stałych do nazwania wartości, którą określasz raz, ale której używasz w wielu miejscach ”.

var myVariable = 42
myVariable = 50
let myConstant = 42

Przeczytaj „Swift Programming Language”.

Jeśli chcesz pracować z Array(Swift) tak jak z NSArray, możesz użyć prostej funkcji pomostu. Przykład:

var arr1 : Array = []

arr1.bridgeToObjectiveC().count

Działa tak samo w przypadku let.

Z własnych dokumentów Apple:

Zmienność zbiorów

Jeśli utworzysz tablicę, zestaw lub słownik i przypiszesz je do zmiennej, utworzona kolekcja będzie modyfikowalna. Oznacza to, że możesz zmienić (lub zmutować) kolekcję po jej utworzeniu, dodając, usuwając lub zmieniając elementy w kolekcji. I odwrotnie, jeśli przypiszesz tablicę, zestaw lub słownik do stałej, ta kolekcja jest niezmienna, a jej rozmiaru i zawartości nie można zmienić.

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

Inne zastosowania niezmiennych / modyfikowalnych kolekcji zależą od tego, dlaczego chcesz, aby były mutowalne / niezmienne. Kolekcje są typami wartości w języku Swift, co oznacza, że ​​ich zawartość jest kopiowana, gdy zostanie przypisana do innej wartości lub przesłana do innej funkcji / metody. Dlatego nie musisz się martwić, czy funkcja metody odbierającej może zmienić oryginalną tablicę. Dlatego nie musisz zwracać niezmiennej kolekcji, jeśli na przykład Twoja klasa zawiera kolekcję mutowalną.

[Niemodyfikowalne i niezmienne]

Tablicę Swifta można wyciszyć

[let vs var, wartość vs typ odniesienia]

Niezmienna kolekcja ^[Informacje] - to struktura kolekcji, której nie można zmienić. Oznacza to, że nie możesz dodawać, usuwać, modyfikować po utworzeniu

let + struct(takie jak Array, Set, Dictionary) jest bardziej odpowiedni do niezmienne

Istnieje kilka klas (np. NSArray), Które nie zapewniają interfejsu do zmiany stanu wewnętrznego

ale

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)
}   

Wolałabym raczej unmodifiabletablica