Wie verkette oder füge ich Arrays in Swift zusammen?

Wenn zwei Arrays wie folgt schnell erstellt werden:

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

Wie können sie zusammengeführt werden [1, 2, 3, 4, 5, 6]?

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 hängen Sie ein Array mit +=(oder append) an das andere an :

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]

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ühren Sie zwei Arrays mit Arraydem +(_:_:)generischen Operator 's zu einem neuen Array zusammen

Arrayhat einen +(_:_:)generischen Operator. +(_:_:)hat die folgende Erklärung :

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 vom Typ [Int]mit einem +(_:_:)generischen Operator zu einem neuen Array zusammengeführt 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 Arraydem +=(_:_:)generischen Operator von ' in ein vorhandenes Array ein

Arrayhat einen +=(_:_:)generischen Operator. +=(_:_:)hat die folgende Erklärung :

Hängt die Elemente einer Sequenz an eine vom Bereich austauschbare 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 einem +=(_:_:)generischen 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. Hängen Sie ein Array mit Arrayder append(contentsOf:)Methode von an ein anderes Array an

Swift Arrayhat eine append(contentsOf:)Methode. append(contentsOf:)hat die folgende Erklärung :

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 Beispielcode für den Spielplatz zeigt, wie ein Array [Int]mithilfe der folgenden append(contentsOf:)Methode an ein anderes Array vom Typ 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ühren Sie zwei Arrays mit Sequenceder flatMap(_:)Methode von ' zu einem neuen Array zusammen

Swift bietet eine flatMap(_:)Methode für alle Typen, die dem SequenceProtokoll entsprechen (einschließlich Array). flatMap(_:)hat die folgende Erklärung :

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 vom Typ [Int]mithilfe der folgenden flatMap(_:)Methode zu einem neuen Array zusammengeführt 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ühren Sie zwei Arrays mit Sequenceder joined()Methode und Arraydem init(_:)Initialisierer eines neuen Arrays zu einem neuen Array zusammen

Swift bietet eine joined()Methode für alle Typen, die dem SequenceProtokoll entsprechen (einschließlich Array). joined()hat die folgende Erklärung :

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

func joined() -> FlattenSequence<Self>

Außerdem hat Swift Arrayeinen init(_:)Initialisierer. init(_:)hat die folgende Erklärung :

Erstellt ein Array mit den Elementen einer Sequenz.

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

Daher zeigt der folgende Playground-Beispielcode, wie zwei Arrays vom Typ [Int]mithilfe von joined()Methode und init(_:)Initialisierer zu einem neuen Array zusammengeführt 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ühren Sie zwei Arrays mit Arrayder reduce(_:_:)Methode von ' zu einem neuen Array zusammen

Swift Arrayhat eine reduce(_:_:)Methode. reduce(_:_:)hat die folgende Erklärung :

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 Spielplatzcode zeigt, wie zwei Arrays vom Typ [Int]mithilfe der folgenden reduce(_:_:)Methode zu einem neuen Array zusammengeführt 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 Überlastung des Bedieners oder eher ein Funktionstyp 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 wird zurückkehren FlattenBidirectionalCollection, wenn Sie nur eine wollen, CollectionTypewird dies ausreichen und Sie werden eine faule Bewertung kostenlos haben. 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, reducekönnte verwendet werden, um das Verhalten von Abflachen zu implementieren :

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

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

Die beste Alternative (Leistung / Speicher) unter den vorgestellten ist einfach flatten, die ursprünglichen Arrays nur träge zu verpacken, ohne eine neue Array-Struktur zu erstellen.

Beachten Sie aber , dass Flatten nicht zurück ein LazyCollection, so dass faule Verhalten wird nicht entlang der Kette (Karte, flatMap, Filter, etc ...) , um die nächste Operation vermehrt werden.

Wenn lazyness Sinn in Ihrem speziellen Fall macht, nur nicht vergessen , zu prepend oder hängen Sie .lazyan flatten(), zum Beispiel zu modifizieren Tomasz Probe auf diese Weise:

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

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] 

Swift 3.0

Sie können ein neues Array erstellen, indem Sie zwei vorhandene Arrays mit kompatiblen Typen mit dem Additionsoperator ( +) addieren . Der Typ des neuen Arrays wird aus dem Typ der beiden Arrays abgeleitet, 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.

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

wenn Sie ein Ergebnis wünschen 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 ein Ergebnis wie folgt wünschen: [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, besteht darin, 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]

Ebenso 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

Marge-Array mit unterschiedlichen 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]]