Wat zijn de nuances van werken met arrays bij het…

Bij het toevoegen van elementen aan arrays in Swift, moet je rekening houden met:

Mutabiliteit: Arrays gedeclareerd met var zijn wijzigbaar en staan toe dat je elementen toevoegt, verwijdert en wijzigt. Arrays gedeclareerd met let zijn onveranderlijk en kunnen na initialisatie niet worden gewijzigd.
```
let onveranderlijkeArray = [1, 2, 3]
// onveranderlijkeArray.append(4) // Compileerfout

var wijzigbareArray = [1, 2, 3]
wijzigbareArray.append(4) // Werkt
```
Prestaties: Elementen toevoegen aan het einde van de array (append) is meestal efficiënt, omdat er in de meeste gevallen vrije ruimte in het toegewezen geheugen is. Echter, als de array vol raakt, vindt er een geheugenherverdeling plaats, wat kostbaar kan zijn en de prestaties kan beïnvloeden, vooral bij frequente toevoegingen. Elementen toevoegen aan het begin of in het midden (insert) vereist het verschuiven van bestaande elementen, wat O(n) tijd kost (waar n het aantal elementen na de insertiepunt is).
Type van elementen: Arrays zijn van één type. Het proberen toe te voegen van een element van een ander type geeft een compileerfout.
```
var intArray = [1, 2, 3]
// intArray.append("hallo") // Compileerfout
```
Meerdere elementen toevoegen: Methoden zoals append(contentsOf:) maken het mogelijk de inhoud van een andere array of sequentie toe te voegen, wat efficiënter kan zijn dan sequentieel toevoegen van individuele elementen.
```
var array1 = [1, 2]
let array2 = [3, 4]
array1.append(contentsOf: array2) // nu array1 is [1, 2, 3, 4]
```
Overflow bij toevoegen (Int/UInt): Bij het werken met arrays van gehele getal typen (Int, UInt), moet je rekening houden met het risico op overflow bij het uitvoeren van wiskundige bewerkingen met indices of waarden, als dat relevant is voor de toevoeglogica.
Indexering: Bij gebruik van index-inserties (insert(_:at:)) moet je ervoor zorgen dat de index binnen het geldige bereik 0...count ligt. Het gebruik van een index buiten dit bereik veroorzaakt een runtime-fout (crash).
Capaciteitsreservering: Als de maximale capaciteit van de array ongeveer of precies bekend is, kun je vooraf geheugen reserveren met reserveCapacity(). Dit kan de prestaties verbeteren door meerdere geheugenherverdelingen te voorkomen.
```
var efficiënteArray = [Int]()
efficiënteArray.reserveCapacity(100) // Reserveer ruimte voor tot 100 elementen
for i in 1...100 {
    efficiënteArray.append(i) // Append-operaties worden sneller
}
```

Wat zijn de nuances van werken met arrays bij het toevoegen van gegevens?