Quelle est la différence entre les collections Swift…

Les différences clés entre les collections Swift (Array, Dictionary, Set) et celles d'autres langages (par exemple, Java, C#, Objective-C) sont les suivantes :

Sécurité de type et inférence de type : Les collections Swift sont intrinsèquement sûres en termes de types. Le type des éléments est déterminé lors de l'initialisation ou de l'ajout du premier élément. La vérification en temps de compilation empêche les erreurs de type à l'exécution.
```
var numbers: [Int] = [1, 2, 3] // Typage explicite
var strings = ["a", "b", "c"] // Inférence de type
// numbers.append("hello") // Erreur de compilation : Cannot convert value of type 'String' to expected argument type 'Int'
```
Dans les langages avec des systèmes de types moins stricts (par exemple, Objective-C sans annotations), les types d'éléments peuvent être @id, ce qui nécessite des vérifications de type à l'exécution.
Types de valeur (structures) : Array, Dictionary et Set en Swift sont des structures (types de valeur), et non des classes (types de référence). Lors de l'assignation ou du passage à une fonction, une copie de la collection est créée.
```
var arrayA = [1, 2, 3]
var arrayB = arrayA // Copie de la collection
arrayB.append(4)

print(arrayA) // Résultat : [1, 2, 3]
print(arrayB) // Résultat : [1, 2, 3, 4]
```
Dans la plupart des autres langages, les collections sont des classes, et l'assignation crée une référence à la même collection. C'est important pour la gestion de la mémoire et le comportement prévisible. Swift utilise l'optimisation "copy-on-write" pour les structures de collection, rendant la copie efficace si la collection n'est pas modifiée.
Optionalité des éléments : Les collections Swift peuvent contenir des types optionnels, ce qui indique explicitement la possibilité qu'un élément soit absent.
```
var optionalNumbers: [Int?] = [1, nil, 3]
```
Cela diffère des langages où nil (ou équivalent) peut être assigné à n'importe quel élément d'une collection de types de référence sans indication explicite d'optionalité.
Méthodes fonctionnelles puissantes : Swift offre un ensemble riche de méthodes pour travailler avec des collections en style fonctionnel : map, filter, reduce, forEach, compactMap et autres.
```
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
```
Bien que de nombreux autres langages aient également ces capacités, en Swift elles sont intégrées de manière plus fluide et font partie de la bibliothèque standard.
Protocoles et Extensions : Les collections Swift respectent plusieurs protocoles (Collection, Sequence, MutableCollection, RandomAccessCollection, etc.), ce qui permet de créer des fonctions génériques et des extensions qui fonctionnent avec tout type de collection implémentant ces protocoles.
```
extension Collection {
    func printElements() {
        for element in self {
            print(element)
        }
    }
}

let myArray = [10, 20, 30]
myArray.printElements() // Fonctionne pour Array

let mySet: Set = [1, 2, 3]
mySet.printElements() // Fonctionne pour Set
```
Cette approche basée sur les protocoles est plus flexible que les hiérarchies de classes utilisées dans certains autres langages.
Indexation et accès : L'indexation en Swift est sûre. Tenter d'accéder avec un index non valide génère une erreur à l'exécution (plage hors limites).

Il est important de noter que, bien qu'Objective-C ait également des collections (NSArray, NSDictionary, NSSet), celles-ci sont des classes basées sur NSObject, non sûres en termes de types par défaut (avant l'introduction des génériques en temps de compilation) et ne sont pas des types de valeur. Les collections Swift offrent une approche plus moderne, sûre et efficace.

Quelle est la différence entre les collections Swift et celles d'autres langages de programmation?