Quels sont les nuances du travail avec des tableaux…

Lors de l'ajout d'éléments aux tableaux en Swift, il faut prendre en compte :

Mutabilité : Les tableaux déclarés avec var sont modifiables et permettent d'ajouter, de supprimer et de modifier des éléments. Ceux déclarés avec let sont immuables et, une fois initialisés, leur contenu ne peut pas être modifié.
```
let tableauImmutable = [1, 2, 3]
// tableauImmutable.append(4) // Erreur de compilation

var tableauMutable = [1, 2, 3]
tableauMutable.append(4) // Fonctionne
```
Performance : Ajouter des éléments à la fin du tableau (append) est généralement efficace, car la plupart du temps il y a de l'espace libre en mémoire allouée. Cependant, si le tableau devient plein, une réallocation de mémoire se produit, ce qui peut être coûteux et affecter la performance, surtout avec des ajouts fréquents. Ajouter des éléments au début ou au milieu (insert) nécessite de décaler les éléments existants, ce qui a une complexité O(n) en temps (où n est le nombre d'éléments après le point d'insertion).
Type d'éléments : Les tableaux sont de type unique. Tenter d'ajouter un élément d'un autre type entraînera une erreur de compilation.
```
var tableauEntiers = [1, 2, 3]
// tableauEntiers.append("bonjour") // Erreur de compilation
```
Insertion de plusieurs éléments : Des méthodes comme append(contentsOf:) permettent d'ajouter le contenu d'un autre tableau ou séquence, ce qui peut être plus efficace que d'ajouter les éléments un par un.
```
var tableau1 = [1, 2]
let tableau2 = [3, 4]
tableau1.append(contentsOf: tableau2) // maintenant tableau1 est [1, 2, 3, 4]
```
Dépassement lors de l'ajout (Int/UInt) : Lorsqu'on travaille avec des tableaux de types entiers (Int, UInt), il faut garder à l'esprit le risque de dépassement lors d'opérations arithmétiques avec des indices ou des valeurs, si cela est pertinent pour la logique d'ajout.
Indexation : Lors de l'utilisation de l'insertion par index (insert(_:at:)), il faut s'assurer que l'index est dans la plage valide 0...count. Utiliser un index hors de cette plage provoquera une erreur à l'exécution (crash).
Réservation de capacité : Si la capacité maximale approximative ou exacte du tableau est connue à l'avance, on peut réserver de la mémoire à l'avance avec reserveCapacity(). Cela peut améliorer la performance en évitant plusieurs réallocations de mémoire.
```
var tableauEfficace = [Int]()
tableauEfficace.reserveCapacity(100) // Réserver de l'espace pour jusqu'à 100 éléments
for i in 1...100 {
    tableauEfficace.append(i) // Les opérations d'ajout seront plus rapides
}
```

Quels sont les nuances du travail avec des tableaux lors de l'ajout de données ?