แผ่อาร์เรย์ของอาร์เรย์ใน Swift

มีคู่ใน Swift ถึงflattenใน Scala, Xtend, Groovy, Ruby และ 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] 

แน่นอนฉันสามารถใช้ลดสำหรับที่ แต่ครับครับ

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

ในห้องสมุดมาตรฐาน Swift มีjoinedฟังก์ชั่นการใช้งานสำหรับทุกประเภทที่สอดคล้องกับSequenceโปรโตคอล (หรือflattenเปิดSequenceTypeก่อน Swift 3) ซึ่งรวมถึงArray:

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

ในบางกรณีการใช้งานjoined()จะมีประโยชน์เนื่องจากจะส่งคืนคอลเล็กชันที่ขี้เกียจแทนอาร์เรย์ใหม่ แต่สามารถแปลงเป็นอาร์เรย์ได้เสมอเมื่อถูกส่งไปยังArray()เริ่มต้นเช่นในตัวอย่างด้านบน

Swift 4.x / 5.x

เพียงแค่เพิ่มความซับซ้อนให้กับอาร์เรย์เพียงเล็กน้อยถ้ามีอาร์เรย์ที่มีอาร์เรย์ของอาร์เรย์flatMapอยู่จริง ๆก็จะล้มเหลว

สมมติว่าอาร์เรย์คือ

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

อะไรflatMapหรือcompactMapผลตอบแทนคือ:

array.compactMap({$0})

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

เพื่อแก้ปัญหานี้เราสามารถใช้การวนรอบแบบลอจิก + การเรียกซ้ำแบบง่าย ๆ ของเรา

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
}

ดังนั้นเรียกใช้ฟังก์ชันนี้กับอาร์เรย์ที่กำหนด

flattenedArray(array: array)

ผลลัพธ์คือ:

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

ฟังก์ชั่นนี้จะช่วยทำให้อาเรย์ประเภทใด ๆ แบนราบพิจารณากรณีของIntที่นี่

เอาท์พุทสนามเด็กเล่น:

Swift 4.x

การใช้งานflatMapนี้ไม่ได้ถูกคัดค้านและใช้เพื่อการนี้ 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] 

แก้ไข:ใช้joined()แทน:

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

คำตอบเดิม:

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

สวิฟท์ 4.2

ฉันเขียนส่วนขยายอาร์เรย์แบบง่ายด้านล่าง คุณสามารถใช้เพื่อทำให้เรียบอาร์เรย์ที่มีอาร์เรย์หรือองค์ประกอบอื่น ซึ่งแตกต่างจากวิธีการเข้าร่วม ()

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

การใช้งาน:

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

numbers.flatten()

อีกประการหนึ่งการดำเนินงานทั่วไปมากขึ้นของreduce,

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

สิ่งนี้สำเร็จเหมือนกัน แต่อาจให้รายละเอียดเพิ่มเติมเกี่ยวกับสิ่งที่เกิดreduceขึ้น

จากเอกสารของ Apple

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

ลักษณะ

กลับผลจากการซ้ำ ๆ เรียกรวมมีมูลค่าสะสมเริ่มต้นที่จะเริ่มต้นและองค์ประกอบของแต่ละลำดับในทางกลับกัน

Modified @ RahmiBozdag คำตอบของ 1. วิธีการในส่วนขยายสาธารณะเป็นสาธารณะ 2. ลบวิธีพิเศษเนื่องจากดัชนีเริ่มต้นจะเป็นศูนย์เสมอ 3. ฉันไม่พบวิธีที่จะวาง compactMap ไว้ภายในสำหรับศูนย์และตัวเลือกได้เนื่องจากวิธีการภายใน T อยู่เสมอ [มี?] คำแนะนำใด ๆ จะได้รับการต้อนรับ

 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]

คุณสามารถแผ่อาร์เรย์ที่ซ้อนกันได้โดยใช้วิธีการต่อไปนี้:

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 เวอร์ชัน 5.1.2 (swiftlang-1100.0.278 clang-1100.0.33.9)
เป้าหมาย: 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]

สวิฟท์ 5.1

public extension Array where Element: Collection {

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

ในกรณีที่คุณต้องการใช้เป็นค่าพจนานุกรม:

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

flatten()ถูกเปลี่ยนชื่อเป็นjoined()ใน Swift 3 ต่อ SE-0133:

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

เมทริกซ์คือ [[myDTO]]?

ใน swift 5 คุณสามารถใช้ = 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)
}