Si hay dos arrays creados en swift como este:
var a:[CGFloat] = [1, 2, 3] var b:[CGFloat] = [4, 5, 6]
¿Cómo se pueden fusionar a [1, 2, 3, 4, 5, 6]
?
Puede concatenar las matrices con +
, creando una nueva matriz
let c = a + b print(c) // [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
o agregar una matriz a la otra con +=
(o extend
):
a += b // Or: a.extend(b) // Swift 1.2 a.appendContentsOf(b) // Swift 2 a.append(contentsOf: b) // Swift 3 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 forms siguientes para concatenar / fusionar dos matrices.
+(_:_:)
Swift standard library
La biblioteca estándar Swift define un operador genérico +(_:_:)
. +(_:_:)
tiene la siguiente statement :
func +<RRC1 : RangeReplaceableCollection, RRC2 : RangeReplaceableCollection where RRC1.Iterator.Element == RRC2.Iterator.Element>(lhs: RRC1, rhs: RRC2) -> RRC1
Crea una nueva colección concatenando los elementos de dos collections.
El siguiente código de Playground muestra cómo combinar dos matrices de 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]
append(contentsOf:)
Array
append(contentsOf:)
Swift Array
tiene un método append(contentsOf:)
. append(contentsOf:)
tiene la siguiente statement :
public mutating func append<S>(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]
usando 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]
flatMap(_:)
Sequence
Swift proporciona un flatMap(_:)
para todos los types que se ajustan al protocolo de Sequence
(incluida la Array
). flatMap(_:)
tiene la siguiente statement :
func flatMap<SegmentOfResult : Sequence>(_ 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 flatMap(_:)
juegos muestra cómo combinar dos matrices de tipo [Int]
en una nueva matriz utilizando 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]
Sequence
's joined()
y el init(_:)
Array
init(_:)
Swift proporciona un método joined()
para todos los types que se ajustan al protocolo de Sequence
(incluida la Array
). joined()
tiene la siguiente statement :
func joined() -> FlattenSequence<Self>
Devuelve los elementos de esta secuencia de secuencias, concatenada.
Además, Swift Array
tiene un init(_:)
inicializador. init(_:)
tiene la siguiente statement :
init<S : Sequence where S.Iterator.Element == Element>(_ s: S)
Crea una matriz que contiene los elementos de una secuencia.
Por lo tanto, el siguiente código de Zona de juegos 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<Int>]> let flattenArray = Array(flattenCollection) print(flattenArray) // prints [1, 2, 3, 4, 5, 6]
networkinguce(_:_:)
Array
networkinguce(_:_:)
Swift Array
tiene un método de networkinguce(_:_:)
. networkinguce(_:_:)
tiene la siguiente statement :
func networkinguce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
Devuelve el resultado de llamar al cierre de combinación dado con cada elemento de esta secuencia y un valor de acumulación.
El siguiente código de Playground muestra cómo combinar dos matrices de tipo [Int]
en una nueva matriz usando el método networkinguce(_:_:)
:
let array1 = [1, 2, 3] let array2 = [4, 5, 6] let flattenArray = [array1, array2].networkinguce([], { (result: [Int], element: [Int]) -> [Int] in return result + element }) print(flattenArray) // prints [1, 2, 3, 4, 5, 6]
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 tipo de CollectionType
, será suficiente y tendrás una evaluación holgazana de forma gratuita. Si necesita exactamente el Array, puede hacer esto:
let c = Array([a, b].flatten())
Si no eres un gran fanático de la sobrecarga del operador, o simplemente más de un tipo funcional:
let result = [ ["merge", "me"], ["We", "shall", "unite"], ["magic"] ].flatMap { $0 }
Para completar la list de posibles alternativas, networkinguce
podría usarse para implementar el comportamiento de flatten :
var a = ["a", "b", "c"] var b = ["d", "e", "f"] let res = [a, b].networkinguce([],combine:+)
La mejor alternativa (performance / memory) entre las presentadas es simplemente flatten
, que solo envuelve las matrices originales perezosamente sin crear una nueva estructura de matrices.
Pero observe que aplanar no devuelve una LazyColletion
, por lo que el comportamiento perezoso no se propagará a la siguiente operación a lo largo de la cadena (map, plano, filter, etc.).
Si la laxitud tiene sentido en su caso particular, simplemente recuerde agregar o agregar un .lazy
para flatten()
, por ejemplo, modificando el ejemplo de Tomasz de esta manera:
let c = [a, b].lazy.flatten()
Si desea que se inserte la segunda matriz después de un índice particular, puede hacer esto (a partir de Swift 2.2):
let index = 1 if 0 ... a.count ~= index { a[index..<index] = b[0..<b.count] } print(a) // [1.0, 4.0, 5.0, 6.0, 2.0, 3.0]
Swift 3.0
Puede crear una nueva matriz agregando dos matrices existentes con types compatibles con el operador de adición ( +
). El tipo de matriz nueva se infiere del tipo de matriz que agregue,
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 manera más breve 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 diferentes types de datos:
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]]