Unión de arrays en Swift: de + a copy-on-write

¿Cómo unir arrays en Swift? Análisis completo con ejemplos y secretos de rendimiento

Si alguna vez has programado en Swift, seguro te has enfrentado a la tarea: «Tengo dos arrays, ¿cómo hago uno solo?». La pregunta parece simple, pero detrás de ella se esconde todo un mundo de optimizaciones y matices. En Stack Overflow, esta pregunta ha acumulado miles de visitas, y con razón. Hoy no solo mostraremos cómo escribir código, sino que miraremos bajo el capó del compilador y descubriremos qué sucede realmente cuando escribes array1 + array2. ¡Allá vamos!

La forma más obvia: el operador +

Empecemos con lo clásico. En Swift, los arrays se pueden sumar como números:

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

¿Bonito? Sí. ¿Rápido? No siempre. Cuando usas +, Swift crea un nuevo array y copia en él los elementos de ambos arrays originales. Si tus arrays son grandes (digamos, de 100 000 elementos cada uno), esto es trabajo doble para el procesador. Pero espera, hay un matiz llamado copy-on-write (COW).

La magia de Copy-on-Write: cómo Swift ahorra memoria

Swift es un lenguaje inteligente. Cuando simplemente asignas un array a otro, no copia los datos de inmediato:

var a = [1, 2, 3]var b = a // Mientras los datos no se modifiquen, a y b apuntan a la misma área de memoriab.append(4) // Aquí es donde ocurre la copia real: b obtiene su propia copia

Esto se llama copy-on-write. Pero al unir con +, esto no funciona: el resultado siempre es un array nuevo. ¿Por qué? Porque no solo hacemos referencia a los datos antiguos, sino que creamos una nueva colección a partir de elementos de dos fuentes diferentes. El compilador no puede garantizar que los arrays originales no cambien, por lo que hace una copia completa.

El método append(contentsOf:): cuando la velocidad importa más

Si necesitas agregar elementos de un array al final de otro sin crear un tercer array, usa append(contentsOf:):

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

En este caso, Swift no crea un nuevo array, sino que expande el existente. Si el array numbers tiene suficiente memoria reservada (capacity), los nuevos elementos simplemente se copian en el espacio libre. Si no, ocurre una reasignación de memoria, pero sigue siendo más rápido que crear un array desde cero.

Consejo de profesional: Si sabes que vas a agregar muchos elementos, reserva memoria de antemano con reserveCapacity():

var bigArray: [Int] = []bigArray.reserveCapacity(1000)for i in 0..<1000 {    bigArray.append(i) // ¡Ni una sola copia innecesaria!}

El método flatMap: unión de arrays con transformación

A veces no solo necesitas unir arrays, sino también transformar cada elemento. Aquí es donde flatMap (o compactMap para opcionales) viene al rescate. Estrictamente hablando, flatMap está diseñado para «aplanar» colecciones, pero también se puede usar para concatenar:

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

Bajo el capó, flatMap hace lo mismo que un bucle con append(contentsOf:). Pero el código se vuelve más limpio y legible. Eso sí, si solo necesitas unir dos arrays, no uses flatMap, es redundante.

reduce(into:) para una unión flexible

Si tienes un array de arrays y quieres unirlos con lógica adicional, prueba reduce(into:):

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