Czym różnią się kolekcje Swift od kolekcji w innych…

Kluczowe różnice między kolekcjami Swift (Array, Dictionary, Set) a tymi w innych językach (np. Java, C#, Objective-C) są następujące:

Bezpieczeństwo typów i wnioskowanie typów: Kolekcje Swift są z natury bezpieczne typowo. Typ elementów jest określany podczas inicjalizacji lub dodawania pierwszego elementu. Sprawdzanie w czasie kompilacji zapobiega błędom typu podczas wykonywania.
```
var numbers: [Int] = [1, 2, 3] // Jawne określenie typu
var strings = ["a", "b", "c"] // Wnioskowanie typu
// numbers.append("hello") // Błąd kompilacji: Cannot convert value of type 'String' to expected argument type 'Int'
```
W językach z mniej rygorystycznym systemem typów (np. Objective-C bez adnotacji), typy elementów mogą być @id, co wymaga sprawdzeń typu podczas wykonywania.
Typy wartości (struktury): Array, Dictionary i Set w Swift są strukturami (typami wartości), a nie klasami (typami referencyjnymi). Podczas przypisania lub przekazania do funkcji tworzona jest kopia kolekcji.
```
var arrayA = [1, 2, 3]
var arrayB = arrayA // Kopia kolekcji
arrayB.append(4)

print(arrayA) // Wynik: [1, 2, 3]
print(arrayB) // Wynik: [1, 2, 3, 4]
```
W większości innych języków kolekcje są klasami, a przypisanie tworzy odniesienie do tej samej kolekcji. To jest ważne dla zarządzania pamięcią i przewidywalnego zachowania. Swift używa optymalizacji "copy-on-write" dla struktur kolekcji, co czyni kopiowanie wydajnym, jeśli kolekcja nie jest modyfikowana.
Opcjonalność elementów: Kolekcje Swift mogą zawierać typy opcjonalne, co wyraźnie wskazuje na możliwość braku elementu.
```
var optionalNumbers: [Int?] = [1, nil, 3]
```
To różni się od języków, gdzie nil (lub odpowiednik) może być przypisany dowolnemu elementowi kolekcji typu referencyjnego bez wyraźnego wskazania opcjonalności.
Potężne metody funkcyjne: Swift oferuje bogaty zestaw metod do pracy z kolekcjami w stylu funkcyjnym: map, filter, reduce, forEach, compactMap i inne.
```
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
```
Chociaż wiele innych języków ma te możliwości, w Swift są one zintegrowane bardziej płynnie i stanowią część biblioteki standardowej.
Protokoły i rozszerzenia: Kolekcje Swift spełniają szereg protokołów (Collection, Sequence, MutableCollection, RandomAccessCollection itd.), co pozwala tworzyć funkcje generyczne i rozszerzenia działające z dowolnymi typami kolekcji implementującymi te protokoły.
```
extension Collection {
    func printElements() {
        for element in self {
            print(element)
        }
    }
}

let myArray = [10, 20, 30]
myArray.printElements() // Działa dla Array

let mySet: Set = [1, 2, 3]
mySet.printElements() // Działa dla Set
```
Podejście oparte na protokołach jest bardziej elastyczne niż hierarchie klas używane w niektórych innych językach.
Indeksacja i dostęp: Indeksacja w Swift jest bezpieczna. Próba dostępu za pomocą nieprawidłowego indeksu powoduje błąd w czasie wykonywania (poza zakresem).

Warto zauważyć, że choć w Objective-C istnieją również kolekcje (NSArray, NSDictionary, NSSet), to są to klasy oparte na NSObject, nie są domyślnie bezpieczne typowo (przed wprowadzeniem generyków na poziomie kompilatora) i nie są typami wartości. Kolekcje Swift oferują nowocześniejsze, bezpieczniejsze i wydajniejsze podejście.

Czym różnią się kolekcje Swift od kolekcji w innych językach programowania?