Aplatir un tableau de tableaux dans Swift

Y a-t-il une contrepartie dans Swift à flattenScala, Xtend, Groovy, Ruby and 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] 

Bien sûr, je pourrais utiliser réduire pour ça mais ça craint un peu

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())

Dans la bibliothèque standard Swift il est joinedfonction mise en oeuvre pour tous les types conformes au Sequenceprotocole (ou flattensur SequenceTypeavant Swift 3), qui comprend Array:

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

Dans certains cas, l'utilisation de joined()peut être bénéfique car elle renvoie une collection différée au lieu d'un nouveau tableau, mais peut toujours être convertie en tableau lorsqu'elle est transmise à l' Array()initialiser comme dans l'exemple ci-dessus.

Swift 4.x / 5.x

Juste pour ajouter un peu plus de complexité au tableau, s'il existe un tableau contenant un tableau de tableaux, alors flatMap échouera en fait.

Supposons que le tableau soit

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

Ce que flatMapou compactMapretourne est:

array.compactMap({$0})

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

Afin de résoudre ce problème, nous pouvons utiliser notre logique de boucle for simple + récursivité

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
}

Appelez donc cette fonction avec le tableau donné

flattenedArray(array: array)

Le résultat est:

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

Cette fonction aidera à aplatir tout type de tableau, en considérant le cas de Int ici

Sortie de terrain de jeu:

Swift 4.x

Cette utilisation de flatMapn'est pas obsolète et c'est fait pour cela. 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] 

Modifier: utiliserjoined() place:

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

Réponse originale:

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

Swift 4.2

J'ai écrit une simple extension de tableau ci-dessous. Vous pouvez utiliser pour aplatir un tableau qui contient un autre tableau ou élément. contrairement à la méthode join ().

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)
    }
}

usage:

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

numbers.flatten()

Une autre implémentation plus générique de reduce,

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

Cela accomplit la même chose mais peut donner plus d'informations sur ce qui se passe dans reduce .

À partir de la documentation d'Apple,

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

La description

Renvoie le résultat d'appels répétés combiner avec une valeur accumulée initialisée à initial et chaque élément de séquence , à son tour.

Réponse modifiée de @ RahmiBozdag, 1. Les méthodes dans les extensions publiques sont publiques. 2. Suppression de la méthode supplémentaire, car l'index de départ sera toujours zéro. 3. Je n'ai pas trouvé de moyen de mettre compactMap à l'intérieur pour nil et optionnel car à l'intérieur de la méthode T est toujours [Any?], Toutes les suggestions sont les bienvenues.

 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]

Vous pouvez aplatir un tableau imbriqué à l'aide de la méthode suivante:

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)
Cible: 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([], +)
    }
}

Si vous le souhaitez également pour les valeurs du dictionnaire:

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

flatten() a été renommé en joined() en Swift 3 par SE-0133:

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

matrice est [[myDTO]]?

Dans swift 5, vous pouvez utiliser this = Array (self.matrix! .Joined ())

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)
}