¿Cómo concatenar o combinar matrices en Swift?

Si hay dos arrays creados en swift como este:

var a:[CGFloat] = [1, 2, 3] var b:[CGFloat] = [4, 5, 6] 

¿Cómo pueden fusionarse con [1, 2, 3, 4, 5, 6] ?

Puede concatenar las matrices con + , construyendo una nueva matriz

 let c = a + b print(c) // [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] 

o anexar una matriz a la otra con += (o append ):

 a += b // Or: a.append(contentsOf: b) // Swift 3 a.appendContentsOf(b) // Swift 2 a.extend(b) // Swift 1.2 print(a) // [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] 

Con Swift 3, de acuerdo con sus necesidades y gustos, puede elegir una de las cinco formas siguientes de concatenar / combinar dos matrices.


1. Combinar dos matrices en una nueva matriz con el operador genérico +(_:_:) Swift standard library

La biblioteca estándar Swift define un operador genérico +(_:_:) . +(_:_:) tiene la siguiente statement :

 func +(lhs: RRC1, rhs: RRC2) -> RRC1 

Crea una nueva colección al concatenar los elementos de dos colecciones.

El siguiente código de Playground muestra cómo combinar dos matrices del tipo [Int] en una nueva matriz usando el operador genérico +(_:_:) :

 let array1 = [1, 2, 3] let array2 = [4, 5, 6] let flattenArray = array1 + array2 print(flattenArray) // prints [1, 2, 3, 4, 5, 6] 

2. Agregue una matriz a otra matriz con el método de append(contentsOf:) Array

Swift Array tiene un método append(contentsOf:) . append(contentsOf:) tiene la siguiente statement :

 public mutating func append(contentsOf newElements: S) where S : Sequence, S.Iterator.Element == Element) 

Agrega los elementos de una secuencia o colección al final de esta colección.

El siguiente código de Playground muestra cómo agregar una matriz a otra matriz de tipo [Int] utilizando el método append(contentsOf:) :

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

3. Combinar dos matrices en una nueva matriz con el método flatMap(_:) Sequence

Swift proporciona un flatMap(_:) para todos los tipos que se ajustan al protocolo de Sequence (incluido Array ). flatMap(_:) tiene la siguiente statement :

 func flatMap(_ transform: (Self.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] 

Devuelve una matriz que contiene los resultados concatenados de llamar a la transformación dada con cada elemento de esta secuencia.

El siguiente código de Playground muestra cómo combinar dos matrices de tipo [Int] en una nueva matriz usando el flatMap(_:) :

 let array1 = [1, 2, 3] let array2 = [4, 5, 6] let flattenArray = [array1, array2].flatMap({ (element: [Int]) -> [Int] in return element }) print(flattenArray) // prints [1, 2, 3, 4, 5, 6] 

4. Fusiona dos matrices en una nueva matriz con el método joined() Sequence y el init(_:) Array

Swift proporciona un método joined() para todos los tipos que se ajustan al protocolo de Sequence (incluido Array ). joined() tiene la siguiente statement :

 func joined() -> FlattenSequence 

Devuelve los elementos de esta secuencia de secuencias, concatenadas.

Además, Swift Array tiene un init(_:) . init(_:) tiene la siguiente statement :

 init(_ s: S) 

Crea una matriz que contiene los elementos de una secuencia.

Por lo tanto, el siguiente código de Playground muestra cómo combinar dos matrices del tipo [Int] en una nueva matriz usando el método joined() y el init(_:) :

 let array1 = [1, 2, 3] let array2 = [4, 5, 6] let flattenCollection = [array1, array2].joined() // type: FlattenBidirectionalCollection< [Array]> let flattenArray = Array(flattenCollection) print(flattenArray) // prints [1, 2, 3, 4, 5, 6] 

5. Combinar dos matrices en una nueva matriz con el método de reduce(_:_:) Array

Swift Array tiene un método de reduce(_:_:) . reduce(_:_:) tiene la siguiente statement :

 func reduce(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result 

Devuelve el resultado de invocar el cierre de combinación dado con cada elemento de esta secuencia y un valor acumulado.

El siguiente código de Playground muestra cómo combinar dos matrices del tipo [Int] en una nueva matriz usando el método reduce(_:_:) :

 let array1 = [1, 2, 3] let array2 = [4, 5, 6] let flattenArray = [array1, array2].reduce([], { (result: [Int], element: [Int]) -> [Int] in return result + element }) print(flattenArray) // prints [1, 2, 3, 4, 5, 6] 

Si no eres un gran admirador de la sobrecarga del operador, o simplemente más de un tipo funcional:

 // use flatMap let result = [ ["merge", "me"], ["We", "shall", "unite"], ["magic"] ].flatMap { $0 } // Output: ["merge", "me", "We", "shall", "unite", "magic"] // ... or reduce [[1],[2],[3]].reduce([], +) // Output: [1, 2, 3] 

Mi método favorito desde Swift 2.0 es aplanar

 var a:[CGFloat] = [1, 2, 3] var b:[CGFloat] = [4, 5, 6] let c = [a, b].flatten() 

Esto devolverá FlattenBidirectionalCollection así que si solo quieres un CollectionType esto será suficiente y tendrás una evaluación perezosa gratis. Si necesita exactamente la matriz, puede hacer esto:

 let c = Array([a, b].flatten()) 

Para completar la lista de posibles alternativas, reduce podría usarse para implementar el comportamiento de aplanar :

 var a = ["a", "b", "c"] var b = ["d", "e", "f"] let res = [a, b].reduce([],combine:+) 

La mejor alternativa (rendimiento / memoria) entre las que se presentan es simplemente flatten , que simplemente envuelve las matrices originales de forma perezosa sin crear una nueva estructura de matriz.

Pero observe que flatten no devuelve una LazyColletion , por lo que el comportamiento lento no se propagará a la siguiente operación a lo largo de la cadena (map, flatMap, filter, etc …).

Si la pereza tiene sentido en su caso particular, simplemente recuerde anteponer o agregar un .lazy a flatten() , por ejemplo, modificando la muestra de Tomasz de esta manera:

 let c = [a, b].lazy.flatten() 

Si desea que se inserte la segunda matriz después de un índice en particular, puede hacerlo (a partir de Swift 2.2):

 let index = 1 if 0 ... a.count ~= index { a[index.. 

Swift 3.0

Puede crear una nueva matriz al agregar juntas dos matrices existentes con tipos compatibles con el operador de sum ( + ). El tipo de matriz nueva se deduce del tipo de las dos matrices que se sumn,

 let arr0 = Array(repeating: 1, count: 3) // [1, 1, 1] let arr1 = Array(repeating: 2, count: 6)//[2, 2, 2, 2, 2, 2] let arr2 = arr0 + arr1 //[1, 1, 1, 2, 2, 2, 2, 2, 2] 

este es el resultado correcto de los códigos anteriores.

Esta es la forma más corta de combinar dos matrices.

  var array1 = [1,2,3] let array2 = [4,5,6] 

Concatenar / fusionarlos

 array1 += array2 New value of array1 is [1,2,3,4,5,6] 

Marge array que son tipos de datos diferentes:

 var arrayInt = [Int]() arrayInt.append(6) var testArray = ["a",true,3,"b"] as [Any] testArray.append(someInt) 

Salida:

 ["a", true, 3, "b", "hi", 3, [6]] 

Del mismo modo, con los diccionarios de matrices, uno puede:

 var dict1 = [String:[Int]]() var dict2 = [String:[Int]]() dict1["key"] = [1,2,3] dict2["key"] = [4,5,6] dict1["key"] = dict1["key"]! + dict2["key"]! print(dict1["key"]!) 

y puede iterar sobre dict1 y agregar dict2 si la “clave” coincide