Swift'te Array'ın ilk 5 nesnesini nasıl geri getirebilirim?

Swift'te, ilk 5 nesneyi döndürmek için Array'da daha yüksek dereceli yöntemleri kullanmanın akıllıca bir yolu var mı? Bunu yapmanın obj-c yolu, bir indeksi kaydetme ve 5 olana kadar dizi artış indeksi arasında geçiş yapma ve yeni diziyi döndürmektir. Bunu yapmanın bir yolu var mı filter, mapyoksa reduce?

Bir Swift dizisinin ilk N elemanını elde etmenin en güzel yolu aşağıdakileri kullanıyor prefix(_ maxLength: Int):

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

Bunun güvenli sınırlar olma avantajı vardır. Eğer geçmek sayımı ise prefixdizi sayısı daha büyüktür o zaman sadece bütün dizi döndürür.

NOT: yorumlarda belirtildiği gibi, Array.prefixaslında bir ArraySlicedeğil, bir döndürür Array. Çoğu durumda bu bir fark yaratmamalıdır, ancak sonucu bir Arraytüre atamanız veya bir Arrayparametre bekleyen bir yönteme aktarmanız gerekiyorsa, sonucu bir Arraytüre zorlamanız gerekir :let first5 = Array(someArray.prefix(5))

Güncelleme: Artık prefixbir dizinin ilk n öğesini almak için kullanma imkanı var . Ön ekin nasıl kullanılacağına ilişkin bir açıklama için @ mluisbrown'un cevabını kontrol edin .

Orijinal Cevap: Sen gerçekten kolay olmadan yapabilir filter, mapya da reducesadece dizinin bir dizi döndürerek:

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

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

Swift 5 ile, ihtiyaçlarınıza göre, sorununuzu çözmek için aşağıdaki 6 Oyun Alanı kodundan birini seçebilirsiniz .

# 1. Alt subscript(_:)simge kullanma

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(_:)Yöntemi kullanarak

Karmaşıklık: O (1) eğer toplama uygunsa RandomAccessCollection; aksi takdirde O ( k ); burada k , koleksiyonun başından itibaren seçilecek öğe sayısıdır.

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 şunları belirtiyor prefix(_:):

Maksimum uzunluk koleksiyondaki öğe sayısını aşarsa, sonuç koleksiyondaki tüm öğeleri içerir.

3.. prefix(upTo:)Yöntemi kullanarak

Karmaşıklık: 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 şunları belirtiyor prefix(upTo:):

Kullanma prefix(upTo:)yöntemi koleksiyonun en alt yazı olarak kısmi bir yarı açık aralığı kullanarak eşdeğerdir. Alt simge gösterimi tercih edilir prefix(upTo:).

4.. prefix(through:)Yöntemi kullanarak

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(_:)Yöntemi kullanarak

Karmaşıklık: O ( n ); burada n , koleksiyonun uzunluğudur.

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(_:)Yöntemi kullanarak

Karmaşıklık: O (1) eğer toplama uygunsa RandomAccessCollection; aksi takdirde, O ( k ), burada k bırakılacak eleman sayısıdır.

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

Farklı bir çözüm:

Diziniz çok kısasa çökmeyecek kolay bir satır içi çözüm

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

Ama bununla iyi çalışıyor.

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

Bunu yaparsanız genellikle bu çökecektir:

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

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

Bir dizinin ilk 5 öğesini elde etmek için tek yapmanız gereken söz konusu diziyi dilimlemek. Swift, sen böyle yapmak: array[0..<5].

Bir dizinin N öğesinin seçimini biraz daha işlevsel ve genelleştirilebilir hale getirmek için, bunu yapmak için bir uzantı yöntemi oluşturabilirsiniz. Örneğin:

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

varYöntem beyanınızın içinde artık desteklenmediği için Markus'un yanıtını en son Swift sürümü için güncellemek için biraz değiştirdim :

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

Hızlı 4

Bir Swift dizisinin ilk N öğesini almak için şunları kullanabilirsiniz prefix(_ maxLength: Int):

Array(largeArray.prefix(5))

Dizi türlerini kaydeden Swift 4

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

Hızlı 4 için güncelleme:

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

Hızlı 3 için:

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

Sade ve Basit

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

Bir dizi nesne için Sıradan bir uzantı oluşturabilirsiniz.

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

Kullanımı:

struct Apple {}

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

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