Làm cách nào để trả về 5 đối tượng đầu tiên của Array trong Swift?

Trong Swift, có cách nào thông minh để sử dụng các phương thức bậc cao hơn trên Array để trả về 5 đối tượng đầu tiên không? Cách làm obj-c là lưu chỉ mục và vòng lặp for thông qua chỉ số tăng mảng cho đến khi 5 và trả về mảng mới. Có cách nào để làm điều này với filter, maphoặc reduce?

Cho đến nay, cách gọn gàng nhất để có được các phần tử N đầu tiên của mảng Swift đang sử dụng prefix(_ maxLength: Int):

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

Điều này có lợi ích là giới hạn an toàn. Nếu số đếm bạn chuyển đến prefixlớn hơn số mảng thì nó chỉ trả về toàn bộ mảng.

LƯU Ý: như được chỉ ra trong các ý kiến, Array.prefixthực sự trả về một ArraySlice, không phải một Array. Trong hầu hết các trường hợp, điều này không tạo ra sự khác biệt nhưng nếu bạn cần gán kết quả cho một Arrayloại hoặc chuyển nó sang một phương thức mong đợi một thông số, Arraybạn sẽ cần buộc kết quả thành một Arrayloại:let first5 = Array(someArray.prefix(5))

Cập nhật: Bây giờ có khả năng sử dụng prefixđể có được n phần tử đầu tiên của một mảng. Kiểm tra câu trả lời của @ mluisbrown để biết giải thích cách sử dụng tiền tố.

Original Trả lời: Bạn có thể làm điều đó thực sự dễ dàng mà không cần filter, maphoặc reducebằng cách chỉ trả lại một loạt các mảng của bạn:

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

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

Với Swift 5, theo nhu cầu của bạn, bạn có thể chọn một trong 6 mã Playground sau để giải quyết vấn đề của mình.

# 1. Sử dụng subscript(_:)chỉ mục

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. Sử dụng prefix(_:)phương pháp

Độ phức tạp: O (1) nếu bộ sưu tập phù hợp với RandomAccessCollection; mặt khác, O ( k ), trong đó k là số phần tử được chọn từ đầu bộ sưu tập.

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 tuyên bố prefix(_:):

Nếu độ dài tối đa vượt quá số phần tử trong bộ sưu tập, kết quả chứa tất cả các phần tử trong bộ sưu tập.

# 3. Sử dụng prefix(upTo:)phương pháp

Độ phức tạp: 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 tuyên bố prefix(upTo:):

Sử dụng prefix(upTo:)phương thức này tương đương với việc sử dụng phạm vi nửa mở một phần làm chỉ mục của bộ sưu tập. Các ký hiệu đăng ký được ưa thích hơn prefix(upTo:).

#4. Sử dụng prefix(through:)phương pháp

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. Sử dụng removeSubrange(_:)phương pháp

Độ phức tạp: O ( n ), trong đó n là chiều dài của bộ sưu tập.

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. Sử dụng dropLast(_:)phương pháp

Độ phức tạp: O (1) nếu bộ sưu tập phù hợp với RandomAccessCollection; mặt khác, O ( k ), trong đó k là số phần tử được thả.

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]

Chuyển 4

Một giải pháp khác nhau:

Một giải pháp nội tuyến dễ dàng không bị sập nếu mảng của bạn quá ngắn

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

Nhưng hoạt động tốt với điều này.

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

Thông thường điều này sẽ sụp đổ nếu bạn làm điều này:

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

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

Để có được 5 phần tử đầu tiên của một mảng, tất cả những gì bạn cần làm là cắt mảng đó trong câu hỏi. Trong Swift, bạn làm như thế này : array[0..<5].

Để làm cho việc chọn N phần tử đầu tiên của một mảng có nhiều chức năng và khái quát hơn, bạn có thể tạo một phương thức mở rộng để thực hiện nó. Ví dụ:

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

Tôi đã thay đổi một chút câu trả lời của Markus để cập nhật nó cho phiên bản Swift mới nhất, vì varbên trong khai báo phương thức của bạn không còn được hỗ trợ:

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

Swift 4

Để có được các phần tử N đầu tiên của mảng Swift, bạn có thể sử dụng prefix(_ maxLength: Int):

Array(largeArray.prefix(5))

Swift 4 với các kiểu mảng lưu

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

Cập nhật cho swift 4:

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

Đối với nhanh chóng 3:

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

Đồng bằng & đơn giản

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

Đối với một mảng các đối tượng, bạn có thể tạo một phần mở rộng từ Sequence.

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

Sử dụng:

struct Apple {}

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

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