ios - ¿Cómo concatenar o combinar matrices en Swift?

arrays merge

Question

Si hay dos matrices creadas en swift así:

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

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

Answer 1

Aquí está la manera más corta de combinar dos matrices.

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

Concatenarlos / fusionarlos

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

Answer 2

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

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

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

func +<RRC1 : RangeReplaceableCollection, RRC2 : RangeReplaceableCollection where RRC1.Iterator.Element == RRC2.Iterator.Element>(lhs: RRC1, rhs: RRC2) -> RRC1

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

El siguiente código de Zona de juegos 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]

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

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

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 Zona de juegos 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]

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

Swift proporciona un flatMap(_:) para todos los tipos que cumplen con el protocolo de Sequence (incluida la Array ). flatMap(_:) tiene la siguiente declaration :

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 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. Combine dos matrices en una nueva matriz con el método Array joined() Sequence y el init(_:) Array .

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

func joined() -> FlattenSequence<Self>

Devuelve los elementos de esta secuencia de secuencias, concatenadas.

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

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 de 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]

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

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

func reduce<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 acumulado.

El siguiente código de Zona de juegos muestra cómo combinar dos matrices de tipo [Int] en una nueva matriz usando el método de 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]

Answer 3

Del mismo modo, con los diccionarios de matrices se 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

Answer 4

Marge array que son diferentes tipos 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]]

Answer 5

Mi método favorito desde Swift 2.0 se flatten

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 el Array, puede hacer esto:

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

Answer 6

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 presentadas es simplemente flatten , que simplemente envuelve los arreglos originales de forma perezosa sin crear una nueva estructura de arreglos.

Pero LazyColletion cuenta que aplanar no devuelve un LazyColletion , por lo que el comportamiento perezoso no se propagará a la siguiente operación a lo largo de la cadena (mapa, mapa plano, filtro, etc.).

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

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

Answer 7

Puedes 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 agregue 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]

Answer 8

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] 

Answer 9

Si no es un gran fanático de la sobrecarga de operadores, 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]

Answer 10

Swift 3.0

Puede crear una nueva matriz sumando dos matrices existentes con tipos compatibles con el operador de suma ( + ). El tipo de la nueva matriz se deduce del tipo de las dos matrices que se agregan,

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.

Answer 11

var arrayOne = [1,2,3]
var arrayTwo = [4,5,6]

si quieres un resultado como: [1,2,3, [4,5,6]]

arrayOne.append(arrayTwo)

El código anterior convertirá a arrayOne como un solo elemento y lo agregará al final de arrayTwo.

si quieres un resultado como: [1, 2, 3, 4, 5, 6] entonces,

arrayOne.append(contentsOf: arrayTwo)

El código anterior agregará todos los elementos de arrayOne al final de arrayTwo.

Gracias.