Quais são as nuances de trabalhar com arrays ao…

Ao adicionar elementos às matrizes em Swift, deve-se ter em mente:

Mutabilidade: As matrizes declaradas com var são mutáveis e permitem adicionar, remover e modificar elementos. As declaradas com let são imutáveis e, uma vez inicializadas, seu conteúdo não pode ser alterado.
```
let arrayimutavel = [1, 2, 3]
// arrayimutavel.append(4) // Erro de compilação

var arraymutavel = [1, 2, 3]
arraymutavel.append(4) // Funciona
```
Desempenho: Adicionar elementos ao final do array (append) é geralmente eficiente, pois na maioria das vezes há espaço livre na memória alocada. No entanto, se o array ficar cheio, ocorre uma realocação de memória, o que pode ser custoso e afetar o desempenho, especialmente com adições frequentes. Adicionar elementos ao início ou no meio (insert) requer deslocar os elementos existentes, o que tem uma complexidade O(n) em tempo (onde n é a quantidade de elementos após o ponto de inserção).
Tipo de elementos: Os arrays são de um único tipo. Tentar adicionar um elemento de outro tipo resultará em erro de compilação.
```
var arrayInteiros = [1, 2, 3]
// arrayInteiros.append("olá") // Erro de compilação
```
Inserção de múltiplos elementos: Métodos como append(contentsOf:) permitem adicionar o conteúdo de outro array ou sequência, o que pode ser mais eficiente do que adicionar elementos um a um.
```
var array1 = [1, 2]
let array2 = [3, 4]
array1.append(contentsOf: array2) // agora array1 é [1, 2, 3, 4]
```
Desbordamento ao adicionar (Int/UInt): Ao trabalhar com arrays de tipos inteiros (Int, UInt), deve-se estar atento ao possível desbordamento ao realizar operações aritméticas com índices ou valores, se isso for relevante para a lógica de adição.
Indexação: Ao usar inserções por índice (insert(_:at:)), certifique-se de que o índice esteja dentro do intervalo válido 0...count. Usar um índice fora desse intervalo causará um erro em tempo de execução (crash).
Reserva de capacidade: Se a capacidade máxima aproximada ou exata do array for conhecida antecipadamente, pode-se reservar memória com antecedência usando reserveCapacity(). Isso pode melhorar o desempenho ao evitar múltiplas realocações de memória.
```
var arrayEficiente = [Int]()
arrayEficiente.reserveCapacity(100) // Reservar espaço para até 100 elementos
for i in 1...100 {
    arrayEficiente.append(i) // Operações de append serão mais rápidas
}
```

Quais são as nuances de trabalhar com arrays ao adicionar dados a eles?