Come restituire i primi 5 oggetti di Array in Swift?

In Swift, c'è un modo intelligente di usare i metodi di ordine superiore su Array per restituire i primi 5 oggetti? Il modo obj-c per farlo era il salvataggio di un indice e il for-loop attraverso l'indice di incremento dell'array fino a quando era 5 e restituendo il nuovo array. C'è un modo per fare questo con filter, mapo reduce?

Di gran lunga il modo più semplice per ottenere i primi N elementi di un array Swift sta usando prefix(_ maxLength: Int):

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

Questo ha il vantaggio di essere al sicuro. Se il conteggio a cui si passa prefixè maggiore del conteggio degli array, restituisce semplicemente l'intero array.

NOTA: come sottolineato nei commenti, Array.prefixrestituisce effettivamente un ArraySlice, non un Array. Nella maggior parte dei casi ciò non dovrebbe fare la differenza, ma se è necessario assegnare il risultato a un Arraytipo o passarlo a un metodo che prevede un Arrayparametro, è necessario forzare il risultato in un Arraytipo:let first5 = Array(someArray.prefix(5))

Aggiornamento: ora è possibile utilizzare prefixper ottenere i primi n elementi di un array. Controlla la risposta di @ mluisbrown per una spiegazione su come usare il prefisso.

Risposta originale: puoi farlo davvero facilmente senza filter, mapo reducesemplicemente restituendo una gamma del tuo array:

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

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

Con Swift 5, in base alle tue esigenze, puoi scegliere uno dei 6 seguenti codici Playground per risolvere il tuo problema.

# 1. Usando il subscript(_:)pedice

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. Usando il prefix(_:)metodo

Complessità: O (1) se la raccolta è conforme RandomAccessCollection; in caso contrario, O ( k ), dove k è il numero di elementi da selezionare dall'inizio della raccolta.

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 afferma per prefix(_:):

Se la lunghezza massima supera il numero di elementi nella raccolta, il risultato contiene tutti gli elementi nella raccolta.

# 3. Usando il prefix(upTo:)metodo

Complessità: 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 afferma per prefix(upTo:):

L'uso del prefix(upTo:)metodo equivale all'utilizzo di un intervallo parziale parzialmente aperto come indice della raccolta. La notazione in pedice è preferita prefix(upTo:).

# 4. Usando il prefix(through:)metodo

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. Usando il removeSubrange(_:)metodo

Complessità: O ( n ), dove n è la lunghezza della raccolta.

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. Usando il dropLast(_:)metodo

Complessità: O (1) se la raccolta è conforme RandomAccessCollection; altrimenti, O ( k ), dove k è il numero di elementi da eliminare.

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

Una soluzione diversa:

Una soluzione inline semplice che non si arresta in modo anomalo se l'array è troppo corto

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

Ma funziona bene con questo.

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

Di solito questo si bloccherebbe se lo facessi:

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

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

Per ottenere i primi 5 elementi di un array, tutto ciò che devi fare è dividere l'array in questione. In Swift, lo si fa in questo modo: array[0..<5].

Per rendere la raccolta degli N primi elementi di un array un po 'più funzionale e generalizzabile, è possibile creare un metodo di estensione per farlo. Per esempio:

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

Ho leggermente modificato la risposta di Markus per aggiornarla per l'ultima versione di Swift, in quanto varla dichiarazione del metodo non è più supportata:

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

Swift 4

Per ottenere i primi N elementi di un array Swift è possibile utilizzare prefix(_ maxLength: Int):

Array(largeArray.prefix(5))

Swift 4 con salvataggio dei tipi di array

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

Aggiornamento per swift 4:

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

Per swift 3:

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

Semplice e chiaro

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

Per una matrice di oggetti è possibile creare un'estensione da Sequenza.

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

Uso:

struct Apple {}

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

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