Wie füge ich Arrays in Swift zusammen oder verschmelze sie?

Question

Wenn in Swift zwei Arrays erstellt werden, wie folgt:

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

Wie können sie zu [1, 2, 3, 4, 5, 6] fusioniert werden?

Answer 1

Sie können die Arrays mit + verketten und ein neues Array erstellen

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

oder ein Array an das andere anhängen mit += (oder append):

a += b

// Oder:
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 2

Mit Swift 5 können Sie gemäß Ihren Anforderungen eine der sechs folgenden Möglichkeiten wählen, um zwei Arrays zu konkatenieren/mergen.

---

1. Fügen Sie zwei Arrays zu einem neuen Array mit dem generischen Operator Array's +(_:_:) zusammen

---

Array hat einen generischen Operator +(_:_:). +(_:_:) hat die folgende Deklaration:

Erstellt eine neue Sammlung durch Konkatenieren der Elemente einer Sammlung und einer Sequenz.

static func + (lhs: Array, rhs: Other) -> Array where Other : Sequence, Self.Element == Other.Element

Der folgende Playground-Beispielcode zeigt, wie Sie zwei Arrays vom Typ [Int] zu einem neuen Array mit dem generischen Operator +(_:_:) zusammenführen können:

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

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

---

2. Hängen Sie die Elemente eines Arrays in ein vorhandenes Array mit dem generischen Operator Array's +=(_:_:) an

---

Array hat einen generischen Operator +=(_:_:). +=(_:_:) hat die folgende Deklaration:

Hängt die Elemente einer Sequenz an eine ersetzbare Sammlung an.

static func += (lhs: inout Array, rhs: Other) where Other : Sequence, Self.Element == Other.Element

Der folgende Playground-Beispielcode zeigt, wie Sie die Elemente eines Arrays vom Typ [Int] in ein vorhandenes Array mit dem generischen Operator +=(_:_:) anhängen können:

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

array1 += array2
print(array1) // gibt [1, 2, 3, 4, 5, 6] aus

---

3. Hängen Sie ein Array an ein anderes Array mit der Methode append(contentsOf:) von Array

---

Swift Array hat eine append(contentsOf:)-Methode. append(contentsOf:) hat die folgende Deklaration:

Fügt die Elemente einer Sequenz oder Sammlung am Ende dieser Sammlung hinzu.

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

~~Der folgende Playground-Beispielcode zeigt, wie Sie ein Array vom Typ [Int] an ein anderes Array mit der Methode append(contentsOf:) anhängen können:

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

array1.append(contentsOf: array2)
print(array1) // gibt [1, 2, 3, 4, 5, 6] aus

---

4. Fügen Sie zwei Arrays zu einem neuen Array mit der Methode flatMap(_:) von Sequence zusammen

---

Swift bietet eine flatMap(_:)-Methode für alle Typen, die dem Sequence-Protokoll entsprechen (inklusive Array). flatMap(_:) hat die folgende Deklaration:

Gibt ein Array zurück, das die konkatenierten Ergebnisse darstellt, wenn die Transformation mit jedem Element dieser Sequenz aufgerufen wird.

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

Der folgende Playground-Beispielcode zeigt, wie Sie zwei Arrays vom Typ [Int] zu einem neuen Array mit der Methode flatMap(_:) zusammenführen können:

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

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

---

5. Fügen Sie zwei Arrays zu einem neuen Array mit der Methode joined() von Sequence und dem Initialisierer init(_:) von Array zusammen

---

Swift bietet eine joined()-Methode für alle Typen, die dem Sequence-Protokoll entsprechen (inklusive Array). joined() hat die folgende Deklaration:

Gibt die Elemente dieser Sequenz von Sequenzen, konkateniert, zurück.

func joined() -> FlattenSequence

Zusätzlich hat Swift Array einen Initialisierer init(_:). init(_:) hat die folgende Deklaration:

Erstellt ein Array, das die Elemente einer Sequenz enthält.

init(_ s: S) where Element == S.Element, S : Sequence

~~Daher zeigt der folgende Playground-Beispielcode, wie Sie zwei Arrays vom Typ [Int] zu einem neuen Array mit der Methode joined() und dem Initialisierer init(_:) zusammenführen können:

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

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

---

6. Fügen Sie zwei Arrays zu einem neuen Array mit der Methode reduce(_:_:) von Array zusammen

---

Swift Array hat eine reduce(_:_:)-Methode. reduce(_:_:) hat die folgende Deklaration:

Liefert das Ergebnis der Kombination der Elemente der Sequenz unter Verwendung des angegebenen Closures.

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

Der folgende Playground-Code zeigt, wie Sie zwei Arrays vom Typ [Int] zu einem neuen Array mit der Methode reduce(_:_:) zusammenführen können:

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) // gibt [1, 2, 3, 4, 5, 6] aus~~~~

Answer 3

Wenn Sie kein großer Fan von Operatorüberladung sind oder einfach mehr ein funktionaler Typ sind:

// Verwenden von flatMap
let result = [
    ["merge", "me"],
    ["Wir", "werden", "vereinen"],
    ["Zauber"]
].flatMap { $0 }
// Ausgabe: ["merge", "me", "Wir", "werden", "vereinen", "Zauber"]

// ... oder reduzieren
[[1],[2],[3]].reduce([], +)
// Ausgabe: [1, 2, 3]

Answer 4

Mein bevorzugter Methode seit Swift 2.0 ist flatten

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

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

Dies wird FlattenBidirectionalCollection zurückgeben, sodass, wenn du nur ein CollectionType möchtest, das ausreicht und du eine Lazy-Evaluation kostenlos erhältst. Wenn du genau das Array benötigst, kannst du dies tun:

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

Answer 5

Um die Liste der möglichen Alternativen zu vervollständigen, könnte reduce verwendet werden, um das Verhalten von flatten zu implementieren:

var a = ["a", "b", "c"] 
var b = ["d", "e", "f"]

let res = [a, b].reduce([],combine:+)

Die beste Alternative (in Bezug auf Leistung/ Speicher) unter den präsentierten ist einfach flatten, das die originalen Arrays einfach lazily umschließt, ohne eine neue Array-Struktur zu erstellen.

Aber beachten Sie, dass flatten keine LazyCollection zurückgibt, sodass das faule Verhalten nicht auf die nächste Operation in der Kette propagiert wird (map, flatMap, filter, usw.).

Wenn Faulheit in Ihrem speziellen Fall sinnvoll ist, denken Sie einfach daran, ein .lazy vor oder nach flatten() hinzuzufügen, beispielsweise Tomasz Beispiel auf diese Weise modifizierend:

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