Jaký je rozdíl mezi kolekcemi Swift a kolekcemi v…

Hlavní rozdíly mezi kolekcemi Swift (Array, Dictionary, Set) a těmi v jiných jazycích (například Java, C#, Objective-C) jsou:

Typová bezpečnost a odvozování typů: Kolekce Swift jsou typově bezpečné. Typ prvku je určen při inicializaci nebo přidání prvního prvku. Kontrola při kompilaci zabraňuje chybám typu za běhu.
```
var numbers: [Int] = [1, 2, 3] // Explicitní typové označení
var strings = ["a", "b", "c"] // Odvození typu
// numbers.append("hello") // Chyba při kompilaci: Cannot convert value of type 'String' to expected argument type 'Int'
```
V jazycích s méně striktním systémem typů (například Objective-C bez anotací) mohou být typy prvků @id, což vyžaduje kontroly typu za běhu.
Hodnotové typy (Structy): Array, Dictionary a Set v Swift jsou struktury (value types), nikoliv třídy (reference types). Při přiřazení nebo předání do funkce se vytvoří kopie kolekce.
```
var arrayA = [1, 2, 3]
var arrayB = arrayA // Kopie kolekce
arrayB.append(4)

print(arrayA) // Výstup: [1, 2, 3]
print(arrayB) // Výstup: [1, 2, 3, 4]
```
Ve většině jiných jazyků jsou kolekce třídy a přiřazení vytváří odkaz na stejnou kolekci. To je důležité pro správu paměti a předvídatelnost chování. Swift používá optimalizaci "copy-on-write" pro struktury kolekcí, což činí kopírování efektivním, pokud se kolekce nemění.
Volitelnost prvků: Kolekce Swift mohou obsahovat volitelné typy, což jasně označuje možnost absence prvku.
```
var optionalNumbers: [Int?] = [1, nil, 3]
```
To se liší od jazyků, kde může být nil (nebo ekvivalent) přiřazen jakémukoliv prvku kolekce odkazového typu bez explicitního označení volitelnosti.
Výkonné funkcionální metody: Swift nabízí bohatou sadu metod pro práci s kolekcemi ve funkcionálním stylu: map, filter, reduce, forEach, compactMap a další.
```
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
```
Ačkoliv tyto možnosti mají i jiné jazyky, ve Swift jsou lépe integrovány a jsou součástí standardní knihovny.
Protokoly a rozšíření: Kolekce Swift odpovídají řadě protokolů (Collection, Sequence, MutableCollection, RandomAccessCollection atd.), což umožňuje vytvářet generické funkce a rozšíření, které fungují s jakýmikoliv typy kolekcí implementujících tyto protokoly.
```
extension Collection {
    func printElements() {
        for element in self {
            print(element)
        }
    }
}

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

let mySet: Set = [1, 2, 3]
mySet.printElements() // Funguje pro Set
```
Tento přístup založený na protokolech je flexibilnější než hierarchie tříd používané v některých jiných jazycích.
Indexování a přístup: Indexování v Swift je bezpečné. Pokus o přístup neplatným indexem vyvolá chybu za běhu (range out of bounds).

Je důležité poznamenat, že ačkoliv v Objective-C existují kolekce (NSArray, NSDictionary, NSSet), jsou to třídy založené na NSObject, nejsou ve výchozím nastavení typově bezpečné (před příchodem generik na úrovni kompilátoru) a nejsou hodnotové typy. Kolekce Swift nabízejí modernější, bezpečnější a výkonnější přístup.

Jaký je rozdíl mezi kolekcemi Swift a kolekcemi v jiných programovacích jazycích?