วิธีการคืนค่า 5 วัตถุแรกของ Array ใน Swift

ใน Swift มีวิธีที่ชาญฉลาดในการใช้วิธีการเรียงลำดับที่สูงขึ้นใน Array เพื่อส่งคืนวัตถุแรก 5 ตัวหรือไม่ วิธี obj-c ในการทำมันคือการบันทึกดัชนีและ for-loop ผ่านดัชนีการเพิ่มอาร์เรย์จนกว่ามันจะเป็น 5 และส่งคืนอาร์เรย์ใหม่ มีวิธีการทำเช่นนี้กับfilter, mapหรือreduce?

เท่าที่ผ่านมาวิธีที่เรียบร้อยที่สุดในการรับองค์ประกอบ N แรกของอาร์เรย์ Swift นั้นใช้prefix(_ maxLength: Int):

let someArray = [1, 2, 3, 4, 5, 6, 7]
let first5 = someArray.prefix(5) // 1, 2, 3, 4, 5

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

หมายเหตุ:เป็นแหลมออกในความคิดเห็นที่Array.prefixจริงกลับไม่ใช่ArraySlice Arrayในกรณีส่วนใหญ่สิ่งนี้ไม่ควรสร้างความแตกต่าง แต่ถ้าคุณต้องการกำหนดผลลัพธ์ให้กับArrayประเภทหรือส่งไปยังวิธีการที่ต้องการArrayพารามิเตอร์คุณจะต้องบังคับผลลัพธ์ให้เป็นArrayประเภท:let first5 = Array(someArray.prefix(5))

อัปเดต: ตอนนี้มีความเป็นไปได้ที่จะใช้prefixเพื่อรับองค์ประกอบ n แรกของอาร์เรย์ ตรวจสอบคำตอบของ @ mluisbrownสำหรับคำอธิบายวิธีใช้คำนำหน้า

คำตอบเดิม: คุณสามารถทำมันง่ายจริงๆโดยไม่filter, mapหรือreduceโดยเพียงแค่กลับมาช่วงของอาร์เรย์ของคุณ:

var wholeArray = [1, 2, 3, 4, 5, 6]
var n = 5

var firstFive = wholeArray[0..<n] // 1,2,3,4,5

ด้วย Swift 5 ตามความต้องการของคุณคุณสามารถเลือกหนึ่งใน6 รหัสสนามเด็กเล่นต่อไปนี้เพื่อแก้ไขปัญหาของคุณ

# 1 ใช้ตัวsubscript(_:)ห้อย

let array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
let arraySlice = array[..<5]
//let arraySlice = array[0..<5] // also works
//let arraySlice = array[0...4] // also works
//let arraySlice = array[...4] // also works
let newArray = Array(arraySlice)
print(newArray) // prints: ["A", "B", "C", "D", "E"]

# 2 ใช้prefix(_:)วิธีการ

ความซับซ้อน: O (1) ถ้าการรวบรวมสอดคล้องกับRandomAccessCollection; มิฉะนั้น O ( k ) โดยที่kคือจำนวนองค์ประกอบที่จะเลือกตั้งแต่ต้นการรวบรวม

let array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
let arraySlice = array.prefix(5)
let newArray = Array(arraySlice)
print(newArray) // prints: ["A", "B", "C", "D", "E"]

Apple ระบุสำหรับprefix(_:):

หากความยาวสูงสุดเกินจำนวนองค์ประกอบในคอลเล็กชันผลลัพธ์จะมีองค์ประกอบทั้งหมดในคอลเล็กชัน

# 3 การใช้prefix(upTo:)วิธีการ

ความซับซ้อน: O (1)

let array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
let arraySlice = array.prefix(upTo: 5)
let newArray = Array(arraySlice)
print(newArray) // prints: ["A", "B", "C", "D", "E"]

Apple ระบุสำหรับprefix(upTo:):

การใช้prefix(upTo:)วิธีการนี้เทียบเท่ากับการใช้ช่วงเปิดครึ่งบางส่วนเป็นตัวห้อยของคอลเล็กชัน prefix(upTo:)สัญกรณ์ห้อยเป็นที่ต้องการมากกว่า

# 4 ใช้prefix(through:)วิธีการ

let array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
let arraySlice = array.prefix(through: 4)
let newArray = Array(arraySlice)
print(newArray) // prints: ["A", "B", "C", "D", "E"]

# 5 ใช้removeSubrange(_:)วิธีการ

ความซับซ้อน: O ( n ) โดยที่nคือความยาวของคอลเลกชัน

var array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
array.removeSubrange(5...)
print(array) // prints: ["A", "B", "C", "D", "E"]

# 6 ใช้dropLast(_:)วิธีการ

ความซับซ้อน: O (1) ถ้าการรวบรวมสอดคล้องกับRandomAccessCollection; มิฉะนั้น O ( k ) โดยที่ k คือจำนวนองค์ประกอบที่จะดรอป

let array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
let distance = array.distance(from: 5, to: array.endIndex)
let arraySlice = array.dropLast(distance)
let newArray = Array(arraySlice)
print(newArray) // prints: ["A", "B", "C", "D", "E"]

let a: [Int] = [0, 0, 1, 1, 2, 2, 3, 3, 4]
let b: [Int] = Array(a.prefix(5))
// result is [0, 0, 1, 1, 2]

SWIFT 4

ทางออกที่แตกต่าง:

โซลูชั่นแบบอินไลน์ที่ง่ายที่จะไม่ผิดพลาดหากอาร์เรย์ของคุณสั้นเกินไป

[0,1,2,3,4,5].enumerated().compactMap{ $0.offset < 3 ? $0.element : nil }

แต่ใช้งานได้ดีกับสิ่งนี้

[0,1,2,3,4,5].enumerated().compactMap{ $0.offset < 1000 ? $0.element : nil }

สิ่งนี้มักจะล้มเหลวหากคุณทำสิ่งนี้:

[0,1,2,3,4,5].prefix(upTo: 1000) // THIS CRASHES

[0,1,2,3,4,5].prefix(1000) // THIS DOESNT

สำหรับการรับ 5 องค์ประกอบแรกของอาเรย์สิ่งที่คุณต้องทำคือการแบ่งอาเรย์ที่มีปัญหา ใน Swift คุณทำสิ่งนี้:array[0..<5]คุณทำเช่นนี้

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

extension Array {
    func takeElements(var elementCount: Int) -> Array {
        if (elementCount > count) {
            elementCount = count
        }
        return Array(self[0..<elementCount])
    }
}

ฉันเปลี่ยนคำตอบของ Markus เล็กน้อยเพื่ออัปเดตเป็น Swift เวอร์ชันล่าสุดเนื่องจากvarการประกาศวิธีการของคุณไม่ได้รับการสนับสนุนอีกต่อไป:

extension Array {
    func takeElements(elementCount: Int) -> Array {
        if (elementCount > count) {
            return Array(self[0..<count])
        }
        return Array(self[0..<elementCount])
    }
}

สวิฟต์ 4

ในการรับองค์ประกอบ N แรกของอาร์เรย์ Swift คุณสามารถใช้prefix(_ maxLength: Int):

Array(largeArray.prefix(5))

Swift 4พร้อมกับประเภทอาเรย์การบันทึก

extension Array {
    func take(_ elementsCount: Int) -> [Element] {
        let min = Swift.min(elementsCount, count)
        return Array(self[0..<min])
    }
}

อัปเดตสำหรับ swift 4:

[0,1,2,3,4,5].enumerated().compactMap{ $0 < 10000 ? $1 : nil }

สำหรับสวิฟท์ 3:

[0,1,2,3,4,5].enumerated().flatMap{ $0 < 10000 ? $1 : nil }

ธรรมดาและเรียบง่าย

extension Array {
    func first(elementCount: Int) -> Array {
          let min = Swift.min(elementCount, count)
          return Array(self[0..<min])
    }
}

สำหรับอาร์เรย์ของวัตถุคุณสามารถสร้างส่วนขยายจากลำดับ

extension Sequence {
    func limit(_ max: Int) -> [Element] {
        return self.enumerated()
            .filter { $0.offset < max }
            .map { $0.element }
    }
}

การใช้งาน:

struct Apple {}

let apples: [Apple] = [Apple(), Apple(), Apple()]
let limitTwoApples = apples.limit(2)

// limitTwoApples: [Apple(), Apple()]