Wie kann ich Arrays in Swift verketten oder zusammenführen?

Mit Swift 5 können Sie je nach Bedarf eine der sechs folgenden Möglichkeiten wählen , um zwei Arrays zu verketten/zusammenzuführen.

# 1. Fügen Sie zwei Arrays mit dem allgemeinen Operator +(_:_:) von Array zu einem neuen Array zusammen

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

Erstellt eine neue Sammlung, indem die Elemente einer Sammlung und einer Sequenz verkettet werden.

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

Der folgende Playground-Beispielcode zeigt, wie zwei Arrays des Typs [Int] mit dem allgemeinen Operator +(_:_:) zu einem neuen Array zusammengefügt werden:

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

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

# 2. Fügen Sie die Elemente eines Arrays mit dem allgemeinen Operator +=(_:_:) von Array in ein vorhandenes Array ein

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

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

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

Der folgende Playground-Beispielcode zeigt, wie die Elemente eines Arrays vom Typ [Int] mit dem allgemeinen Operator +=(_:_:) an ein vorhandenes Array angehängt werden:

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

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

#3. Fügen Sie ein Array mit der Methode append(contentsOf:) von Array an ein anderes Array an

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

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

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

Der folgende Playground-Beispielcode zeigt, wie ein Array mit der Methode append(contentsOf:) an ein anderes Array vom Typ [Int] angehängt wird:

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

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

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

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

Gibt ein Array zurück, das die verketteten Ergebnisse des Aufrufs der angegebenen Transformation mit jedem Element dieser Sequenz enthält.

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

Der folgende Playground-Beispielcode zeigt, wie zwei Arrays des Typs [Int] mit der Methode flatMap(_:) zu einem neuen Array zusammengefügt werden:

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]

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

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

Gibt die Elemente dieser Sequenz von verketteten Sequenzen zurück.

func joined() -> FlattenSequence<Self>

Außerdem hat Swift Array einen init(_:)-Initialisierer. init(_:) hat die folgende Deklaration :

Erstellt ein Array mit den Elementen einer Sequenz.

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

Aus diesem Grund zeigt der folgende Playground-Beispielcode, wie zwei Arrays des Typs [Int] mit der Methode joined() und dem Initializer init(_:) zu einem neuen Array zusammengefügt werden:

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]

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

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

Gibt das Ergebnis der Kombination der Elemente der Sequenz mit dem angegebenen Abschluss zurück.

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

Der folgende Playground-Code zeigt, wie zwei Arrays des Typs [Int] mit der Methode reduce(_:_:) zu einem neuen Array zusammengefügt werden:

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]

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

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

Meine Lieblingsmethode seit Swift 2.0 ist Abflachen

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

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

Dies gibt FlattenBidirectionalCollection zurück. Wenn Sie also nur ein CollectionType möchten, ist dies ausreichend und Sie haben eine kostenlose Testversion. Wenn Sie genau das Array benötigen, können Sie dies tun:

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

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) ist einfach flatten, bei der die ursprünglichen Arrays nur träge umbrochen werden, ohne eine neue Array-Struktur zu erstellen.

Beachten Sie jedoch, dass wird nicht zurückgegeben a LazyCollection, so dass faules Verhalten nicht auf das nächste übertragen wird Betrieb entlang der Kette (Karte, flatMap, Filter, etc ...).

Wenn Faulheit in Ihrem speziellen Fall Sinn macht, denken Sie einfach daran, .lazy vor flatten() einzufügen oder anzuhängen, indem Sie beispielsweise das Tomasz-Beispiel folgendermaßen ändern:

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

Swift 3.

Sie können ein neues Array erstellen, indem Sie zwei vorhandene Arrays mit kompatiblen Typen mit dem Additionsoperator (+) addieren. Der Typ des neuen Arrays ergibt sich aus dem Typ der beiden Arrays, die Sie zusammenfügen.

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]

dies ist das richtige Ergebnis der obigen Codes.

Wenn Sie möchten, dass das zweite Array nach einem bestimmten Index eingefügt wird, können Sie dies tun (ab 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] 

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

wenn du das Ergebnis haben willst als: [1,2,3, [4,5,6]]

arrayOne.append(arrayTwo)

der obige Code konvertiert arrayOne als einzelnes Element und fügt es am Ende von arrayTwo hinzu.

wenn Sie das Ergebnis haben wollen als: [1, 2, 3, 4, 5, 6] dann,

arrayOne.append(contentsOf: arrayTwo)

der obige Code fügt alle Elemente von arrayOne am Ende von arrayTwo hinzu.

Vielen Dank.

Swift 4.X

der einfachste Weg, den ich kenne, ist, einfach das + -Zeichen zu verwenden

var Array1 = ["Item 1", "Item 2"]
var Array2 = ["Thing 1", "Thing 2"]

var Array3 = Array1 + Array2

// Array 3 will just be them combined :)

Hier ist der kürzeste Weg, um zwei Arrays zusammenzuführen.

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

Verketten/zusammenführen

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

Marge-Array mit verschiedenen Datentypen:

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

Ausgabe :

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

Ähnlich kann man mit Wörterbüchern von Arrays:

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"]!)

und Sie können über dict1 iterieren und dict2 hinzufügen, wenn der "Schlüssel" übereinstimmt