Fusion de tableaux en Swift : de + à copy-on-write

Comment fusionner des tableaux en Swift ? Analyse complète avec exemples et secrets de performance

Si vous avez déjà programmé en Swift, vous avez sûrement été confronté à ce problème : « J'ai deux tableaux, comment en faire un seul ? ». La question semble simple, mais elle cache tout un monde d'optimisations et de nuances. Sur Stack Overflow, cette question a recueilli des milliers de vues – et ce n'est pas pour rien. Aujourd'hui, nous ne montrerons pas seulement comment écrire du code, mais nous regarderons sous le capot du compilateur pour découvrir ce qui se passe réellement lorsque vous écrivez array1 + array2. C'est parti !

La méthode la plus évidente : l'opérateur +

Commençons par les classiques. En Swift, les tableaux peuvent s'additionner comme des nombres :

let first = [1, 2, 3]let second = [4, 5, 6]let result = first + secondprint(result) // [1, 2, 3, 4, 5, 6]

Élégant ? Oui. Rapide ? Pas toujours. Lorsque vous utilisez +, Swift crée un nouveau tableau et copie les éléments des deux tableaux sources. Si vos tableaux sont volumineux (disons 100 000 éléments chacun), c'est un double travail pour le processeur. Mais attendez – il y a une subtilité appelée copy-on-write (COW).

La magie du Copy-on-Write : comment Swift économise la mémoire

Swift est un langage intelligent. Lorsque vous assignez simplement un tableau à un autre, il ne copie pas les données immédiatement :

var a = [1, 2, 3]var b = a // Tant que les données ne sont pas modifiées, a et b pointent vers la même zone mémoireb.append(4) // C'est ici que la copie réelle a lieu : b obtient sa propre copie

Cela s'appelle le copy-on-write. Mais lors de la fusion avec +, cela ne fonctionne pas – le résultat est toujours un nouveau tableau. Pourquoi ? Parce que nous ne faisons pas que référencer les anciennes données, nous créons une nouvelle collection à partir d'éléments de deux sources différentes. Le compilateur ne peut pas garantir que les tableaux sources ne seront pas modifiés, il effectue donc une copie complète.

La méthode append(contentsOf:) : quand la vitesse est primordiale

Si vous devez ajouter les éléments d'un tableau à la fin d'un autre sans créer de troisième tableau, utilisez append(contentsOf:) :

var numbers = [1, 2, 3]let moreNumbers = [4, 5, 6]numbers.append(contentsOf: moreNumbers)print(numbers) // [1, 2, 3, 4, 5, 6]

Dans ce cas, Swift ne crée pas de nouveau tableau – il étend le tableau existant. Si le tableau numbers a suffisamment de mémoire réservée (capacity), les nouveaux éléments sont simplement copiés dans l'espace libre. Sinon, une réallocation mémoire a lieu, mais c'est toujours plus rapide que de créer un tableau à partir de zéro.

Conseil de pro : Si vous savez que vous allez ajouter beaucoup d'éléments, allouez la mémoire à l'avance avec reserveCapacity() :

var bigArray: [Int] = []bigArray.reserveCapacity(1000)for i in 0..<1000 {    bigArray.append(i) // Pas une seule copie superflue !}

La méthode flatMap : fusion de tableaux avec transformation

Parfois, il ne s'agit pas seulement de concaténer des tableaux, mais aussi de transformer chaque élément. C'est là que flatMap (ou compactMap pour les optionnels) vient à la rescousse. Strictement parlant, flatMap est conçu pour « aplatir » des collections, mais on peut aussi l'utiliser pour la concaténation :

let arrays = [[1, 2], [3, 4], [5, 6]]let flattened = arrays.flatMap { $0 }print(flattened) // [1, 2, 3, 4, 5, 6]

Sous le capot, flatMap fait la même chose qu'une boucle avec append(contentsOf:). Mais le code devient plus propre et plus lisible. Cependant, si vous avez simplement besoin de concaténer deux tableaux – n'utilisez pas flatMap, c'est superflu.

reduce(into:) pour une fusion flexible

Si vous avez un tableau de tableaux et que vous souhaitez les fusionner avec une logique supplémentaire, essayez reduce(into:) :

let arrayOfArrays = [[1, 2], [3, 4], [5, 6]]let merged = arrayOfArrays.reduce(into: [Int]()) { r