Reduzieren Sie ein Array von Arrays in Swift

Gibt es in Swift ein Gegenstück zu flattenScala, Xtend, Groovy, Ruby und Co.?

var aofa = [[1,2,3],[4],[5,6,7,8,9]]
aofa.flatten() // shall deliver [1,2,3,4,5,6,7,8,9] 

Natürlich könnte ich dafür Reduzieren verwenden, aber das ist irgendwie scheiße

var flattened = aofa.reduce(Int[]()){
    a,i in var b : Int[] = a
    b.extend(i)
    return b
}

Swift> = 3.0

reduce::

let numbers = [[1,2,3],[4],[5,6,7,8,9]]
let reduced = numbers.reduce([], +)

flatMap::

let numbers = [[1,2,3],[4],[5,6,7,8,9]]
let flattened = numbers.flatMap { $0 }

joined::

let numbers = [[1,2,3],[4],[5,6,7,8,9]]
let joined = Array(numbers.joined())

In Swift - Standardbibliothek ist es joinedFunktion für alle Arten implementiert konform SequenceProtokoll (oder flattenauf SequenceTypevor Swift 3), die umfasst Array:

let numbers = [[1,2,3],[4],[5,6,7,8,9]]
let flattened = Array(numbers.joined())

In bestimmten Fällen joined()kann die Verwendung von vorteilhaft sein, da sie eine verzögerte Auflistung anstelle eines neuen Arrays zurückgibt, aber immer in ein Array konvertiert werden kann, wenn sie Array()wie im obigen Beispiel an den Initialisierer übergeben wird.

Swift 4.x / 5.x.

Nur um dem Array etwas mehr Komplexität zu verleihen: Wenn es ein Array gibt, das ein Array von Arrays enthält, schlägt dies flatMaptatsächlich fehl.

Angenommen, das Array ist

var array:[Any] = [1,2,[[3,4],[5,6,[7]]],8]

Was flatMapodercompactMap kehrt zurück ist:

array.compactMap({$0})

//Output
[1, 2, [[3, 4], [5, 6, [7]]], 8]

Um dieses Problem zu lösen, können wir unsere einfache for-Schleifenlogik + Rekursion verwenden

func flattenedArray(array:[Any]) -> [Int] {
    var myArray = [Int]()
    for element in array {
        if let element = element as? Int {
            myArray.append(element)
        }
        if let element = element as? [Any] {
            let result = flattenedArray(array: element)
            for i in result {
                myArray.append(i)
            }

        }
    }
    return myArray
}

Rufen Sie diese Funktion also mit dem angegebenen Array auf

flattenedArray(array: array)

Das Ergebnis ist:

[1, 2, 3, 4, 5, 6, 7, 8]

Diese Funktion hilft dabei, jede Art von Array zu reduzieren, wenn man den Fall Inthier betrachtet

Spielplatzausgabe:

Swift 4.x.

Diese Verwendung von flatMapist nicht veraltet und es ist dafür gemacht. https://developer.apple.com/documentation/swift/sequence/2905332-flatmap

var aofa = [[1,2,3],[4],[5,6,7,8,9]]
aofa.flatMap { $0 } //[1,2,3,4,5,6,7,8,9] 

Bearbeiten: Verwenden Sie joined()stattdessen:

https://developer.apple.com/documentation/swift/sequence/2431985-joined

Ursprüngliche Antwort:

let numbers = [[1, 2, 3], [4, 5, 6]]
let flattenNumbers = numbers.reduce([], combine: +)

Swift 4.2

Ich habe unten eine einfache Array-Erweiterung geschrieben. Sie können ein Array reduzieren, das ein anderes Array oder Element enthält. im Gegensatz zu join () Methode.

public extension Array {
    public func flatten() -> [Element] {
        return Array.flatten(0, self)
    }

    public static func flatten<Element>(_ index: Int, _ toFlat: [Element]) -> [Element] {
        guard index < toFlat.count else { return [] }

        var flatten: [Element] = []

        if let itemArr = toFlat[index] as? [Element] {
            flatten = flatten + itemArr.flatten()
        } else {
            flatten.append(toFlat[index])
        }

        return flatten + Array.flatten(index + 1, toFlat)
    }
}

Verwendung:

let numbers: [Any] = [1, [2, "3"], 4, ["5", 6, 7], "8", [9, 10]]

numbers.flatten()

Eine weitere allgemeinere Implementierung von reduce,

let numbers = [[1,2,3],[4],[5,6,7,8,9]]
let reduced = reduce(numbers,[],+)

Dies bewirkt dasselbe, kann jedoch mehr Einblick in das geben, was in dem Geschehen vor sich geht reduce.

Aus Apples Dokumenten,

func reduce<S : SequenceType, U>(sequence: S, initial: U, combine: (U, S.Generator.Element) -> U) -> U

Beschreibung

Bringen Sie das Ergebnis der wiederholten Aufruf kombinieren mit einem akkumulierten Wert initialisiert anfänglichen und jedes Element der Sequenz , in der Reihe.

Geänderte Antwort von @ RahmiBozdag: 1. Methoden in öffentlichen Erweiterungen sind öffentlich. 2. Zusätzliche Methode entfernt, da der Startindex immer Null ist. 3. Ich habe keine Möglichkeit gefunden, compactMap für Null und Optionen einzufügen, da in Methode T immer [Beliebig?] Ist. Vorschläge sind willkommen.

 let array = [[[1, 2, 3], 4], 5, [6, [9], 10], 11, nil] as [Any?]

 public extension Array {

 func flatten<T>(_ index: Int = 0) -> [T] {
        guard index < self.count else { 
            return [] 
        }

        var flatten: [T] = []

        if let itemArr = self[index] as? [T] {
            flatten += itemArr.flatten()
        } else if let element = self[index] as? T {
            flatten.append(element)
        }
        return flatten + self.flatten(index + 1)
   }

}

let result: [Any] = array.flatten().compactMap { $0 }
print(result)
//[1, 2, 3, 4, 5, 6, 9, 10, 11]

Sie können verschachtelte Arrays mit der folgenden Methode reduzieren:

var arrays = [1, 2, 3, 4, 5, [12, 22, 32], [[1, 2, 3], 1, 3, 4, [[[777, 888, 8999]]]]] as [Any]

func flatten(_ array: [Any]) -> [Any] {

    return array.reduce([Any]()) { result, current in
        switch current {
        case(let arrayOfAny as [Any]):
            return result + flatten(arrayOfAny)
        default:
            return result + [current]
        }
    }
}

let result = flatten(arrays)

print(result)

/// [1, 2, 3, 4, 5, 12, 22, 32, 1, 2, 3, 1, 3, 4, 777, 888, 8999]

Apple Swift Version 5.1.2 (swiftlang-1100.0.278 clang-1100.0.33.9)
Ziel: x86_64-apple-darwin19.2.0

let optionalNumbers = [[1, 2, 3, nil], nil, [4], [5, 6, 7, 8, 9]]
print(optionalNumbers.compactMap { $0 }) // [[Optional(1), Optional(2), Optional(3), nil], [Optional(4)], [Optional(5), Optional(6), Optional(7), Optional(8), Optional(9)]]
print(optionalNumbers.compactMap { $0 }.reduce([], +).map { $0 as? Int ?? nil }.compactMap{ $0 }) // [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(optionalNumbers.compactMap { $0 }.flatMap { $0 }.map { $0 as? Int ?? nil }.compactMap{ $0 }) // [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(Array(optionalNumbers.compactMap { $0 }.joined()).map { $0 as? Int ?? nil }.compactMap{ $0 }) // [1, 2, 3, 4, 5, 6, 7, 8, 9]

let nonOptionalNumbers = [[1, 2, 3], [4], [5, 6, 7, 8, 9]]
print(nonOptionalNumbers.compactMap { $0 }) // [[1, 2, 3], [4], [5, 6, 7, 8, 9]]
print(nonOptionalNumbers.reduce([], +)) // [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(nonOptionalNumbers.flatMap { $0 }) // [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(Array(nonOptionalNumbers.joined())) // [1, 2, 3, 4, 5, 6, 7, 8, 9]

Swift 5.1

public extension Array where Element: Collection {

    func flatten() -> [Element.Element] {
        return reduce([], +)
    }
}

Falls Sie es auch für Wörterbuchwerte möchten:

public extension Dictionary.Values where Value : Collection {
    func flatten() -> [Value.Element]{
         return self.reduce([], +)
    }
}

flatten()wurde joined()in Swift 3 per SE-0133 umbenannt:

https://github.com/apple/swift-evolution/blob/master/proposals/0133-rename-flatten-to-joined.md

Matrix ist myDTO?

In Swift 5 können Sie this = Array (self.matrix! .Joined ()) verwenden.

func convert(){
    let arr = [[1,2,3],[4],[5,6,7,8,9]]
    print("Old Arr = ",arr)
    var newArr = [Int]()
    for i in arr{
        for j in i{
            newArr.append(j)
        }
    }
    print("New Arr = ",newArr)
}