Aký je rozdiel medzi kolekciami Swift a kolekciami v…

Hlavné rozdiely medzi kolekciami Swift (Array, Dictionary, Set) a tými v iných jazykoch (napríklad Java, C#, Objective-C) sú nasledovné:

Typová bezpečnosť a odvodzovanie typov: Kolekcie Swift sú typovo bezpečné. Typ prvku je určený pri inicializácii alebo pridávaní prvého prvku. Kontrola počas kompilácie zabraňuje chybám typu počas behu.
```
var numbers: [Int] = [1, 2, 3] // Jasné definovanie typu
var strings = ["a", "b", "c"] // Odvodzovanie typu
// numbers.append("hello") // Chyba pri kompilácii: Cannot convert value of type 'String' to expected argument type 'Int'
```
V jazykoch s menej prísnym systémom typov (napríklad Objective-C bez anotácií) môžu byť typy prvkov @id, čo vyžaduje kontroly typu počas behu.
Hodnotové typy (Structs): Array, Dictionary a Set v Swift sú štruktúry (value types), nie triedy (reference types). Pri priraďovaní alebo odovzdávaní do funkcie sa vytvorí kópia kolekcie.
```
var arrayA = [1, 2, 3]
var arrayB = arrayA // Kópia kolekcie
arrayB.append(4)

print(arrayA) // Výstup: [1, 2, 3]
print(arrayB) // Výstup: [1, 2, 3, 4]
```
Vo väčšine iných jazykov sú kolekcie triedy a priraďovanie vytvára odkaz na tú istú kolekciu. Toto je dôležité pre správu pamäte a predvídateľnosť správania. Swift používa optimalizáciu "copy-on-write" pre štruktúry kolekcií, čo robí kopírovanie efektívnym, ak sa kolekcia nemení.
Voliteľnosť prvkov: Kolekcie Swift môžu obsahovať voliteľné typy, čo jasne označuje možnosť absencie prvku.
```
var optionalNumbers: [Int?] = [1, nil, 3]
```
Toto sa líši od jazykov, kde nil (alebo ekvivalent) môže byť priradený akémukoľvek prvku kolekcie referenčného typu bez explicitného označenia voliteľnosti.
Silné funkcionálne metódy: Swift poskytuje bohatý súbor metód na prácu s kolekciami vo funkcionálnom štýle: map, filter, reduce, forEach, compactMap a ďalšie.
```
let numbers = [1, 2, 3, 4, 5]
let doubled = numbers.map { $0 * 2 } // [2, 4, 6, 8, 10]
let even = numbers.filter { $0 % 2 == 0 } // [2, 4]
let sum = numbers.reduce(0, +) // 15
```
Hoci mnohé jazyky majú tieto možnosti, v Swift sú lepšie integrované a súčasťou štandardnej knižnice.
Protokoly a rozšírenia: Kolekcie Swift zodpovedajú radu protokolov (Collection, Sequence, MutableCollection, RandomAccessCollection a pod.), čo umožňuje vytváranie generických funkcií a rozšírení, ktoré fungujú s akýmikoľvek typmi kolekcií implementujúcimi tieto protokoly.
```
extension Collection {
    func printElements() {
        for element in self {
            print(element)
        }
    }
}

let myArray = [10, 20, 30]
myArray.printElements() // Funguje pre Array

let mySet: Set = [1, 2, 3]
mySet.printElements() // Funguje pre Set
```
Tento prístup založený na protokoloch je flexibilnejší ako hierarchie tried, používané v niektorých iných jazykoch.
Indexovanie a prístup: Indexovanie v Swift je bezpečné. Pokus o prístup neplatným indexom spôsobí chybu počas behu (range out of bounds).

Je dôležité poznamenať, že hoci v Objective-C existujú kolekcie (NSArray, NSDictionary, NSSet), sú to triedy založené na NSObject, nie sú typovo bezpečné podľa predvolenia (pred objavením sa Generics na úrovni kompilátora) a nie sú hodnotové typy. Kolekcie Swift ponúkajú modernejší, bezpečnejší a výkonnostne efektívnejší prístup.

Aký je rozdiel medzi kolekciami Swift a kolekciami v iných programovacích jazykoch?