Làm phẳng một mảng các mảng trong Swift

Có đối tác trong Swift to flattentrong Scala, Xtend, Groovy, Ruby và co không?

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

tất nhiên tôi có thể sử dụng giảm cho điều đó nhưng điều đó thật tệ

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

Trong thư viện chuẩn Swift có joinedchức năng được triển khai cho tất cả các loại tuân thủ Sequencegiao thức (hoặc flattenbật SequenceTypetrước Swift 3), bao gồm Array:

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

Trong một số trường hợp nhất định, việc sử dụng joined()có thể có lợi vì nó trả về một bộ sưu tập lười biếng thay vì một mảng mới, nhưng luôn có thể được chuyển đổi thành một mảng khi được chuyển sang trình Array()khởi tạo như trong ví dụ trên.

Swift 4.x / 5.x

Chỉ cần thêm một chút phức tạp vào mảng, nếu có một mảng chứa mảng mảng, thì flatMapthực sự sẽ thất bại.

Giả sử mảng là

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

Những gì flatMaphoặc compactMaptrả lại là:

array.compactMap({$0})

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

Để giải quyết vấn đề này, chúng ta có thể sử dụng đơn giản cho logic vòng lặp + đệ quy

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
}

Vì vậy, gọi hàm này với mảng đã cho

flattenedArray(array: array)

Kết quả là:

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

Hàm này sẽ giúp làm phẳng bất kỳ loại mảng nào, xem xét trường hợp Intở đây

Đầu ra sân chơi:

Swift 4.x

Việc sử dụng flatMapnày không được phản đối và nó làm cho điều này. https://developer.apple.com/documentation/swift/fterence/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] 

Chỉnh sửa: Sử dụng joined()thay thế:

https://developer.apple.com/documentation/swift/ resultence / 2431985-tham gia

Trả lời gốc:

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

Swift 4.2

Tôi đã viết một phần mở rộng mảng đơn giản dưới đây. Bạn có thể sử dụng để làm phẳng một mảng có chứa một mảng hoặc phần tử khác. không giống như phương thức tham gia ().

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

sử dụng:

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

numbers.flatten()

Một cách thực hiện chung chung khác của reduce,

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

Điều này hoàn thành điều tương tự nhưng có thể cung cấp cái nhìn sâu sắc hơn về những gì đang diễn ra reduce .

Từ tài liệu của Apple,

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

Sự miêu tả

Trả về kết quả của việc gọi liên tục kết hợp với một giá trị tích lũy được khởi tạo thành ban đầu và lần lượt từng phần tử của chuỗi .

Đã sửa đổi câu trả lời của @ RahmiBozdag, 1. Các phương thức trong tiện ích mở rộng công khai. 2. Loại bỏ phương thức bổ sung, vì chỉ số bắt đầu sẽ luôn bằng không. 3. Tôi không tìm thấy cách đặt compactMap bên trong cho nil và tùy chọn vì bên trong phương thức T luôn là [Bất kỳ?], Bất kỳ đề xuất nào đều được hoan nghênh.

 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]

Bạn có thể làm phẳng mảng lồng nhau bằng phương pháp sau:

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 phiên bản 5.1.2 (swiftlang-1100.0.278 clang-1100.0.33.9)
Mục tiêu: 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([], +)
    }
}

Trong trường hợp bạn cũng muốn nó cho các giá trị từ điển:

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

flatten()đã được đổi tên thành joined()Swift 3 mỗi SE-0133:

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

ma trận là [[myDTO]]?

Trong swift 5, bạn có thể sử dụng 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)
}