Como retornar os 5 primeiros objetos da Matriz no Swift?

No Swift, existe uma maneira inteligente de usar os métodos de ordem superior no Array para retornar os 5 primeiros objetos? A maneira obj-c de fazer isso era salvar um índice e fazer um loop for através do índice, incrementando o índice até os 5 anos e retornando o novo array. Existe uma maneira de fazer isso com filter, mapou reduce?

De longe, a maneira mais pura de obter os primeiros N elementos de uma matriz Swift é usar prefix(_ maxLength: Int):

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

Isso tem o benefício de ser seguro. Se a contagem para a qual você passar prefixfor maior que a contagem da matriz, ela retornará a matriz inteira.

NOTA: como indicado nos comentários, Array.prefixna verdade retorna um ArraySlice, não um Array. Na maioria dos casos, isso não deve fazer diferença, mas se você precisar atribuir o resultado a um Arraytipo ou passá-lo para um método que espera um Arrayparâmetro, será necessário forçar o resultado para um Arraytipo:let first5 = Array(someArray.prefix(5))

Atualização: Agora existe a possibilidade de usar prefixpara obter os primeiros n elementos de uma matriz. Verifique a resposta de @ mluisbrown para obter uma explicação sobre como usar o prefixo.

Resposta original: Você pode fazer isso com muita facilidade sem filter, mapou reduceapenas retornando um intervalo de sua matriz:

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

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

Com o Swift 5, de acordo com suas necessidades, você pode escolher um dos 6 códigos seguintes do Playground para resolver seu problema.

# 1 Usando subscript(_:)subscrito

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 o prefix(_:)método

Complexidade: O (1) se a coleção estiver em conformidade RandomAccessCollection; caso contrário, O ( k ), onde k é o número de elementos a serem selecionados desde o início da coleção.

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"]

A Apple declara para prefix(_:):

Se o comprimento máximo exceder o número de elementos na coleção, o resultado conterá todos os elementos na coleção.

# 3 Usando o prefix(upTo:)método

Complexidade: 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"]

A Apple declara para prefix(upTo:):

Usar o prefix(upTo:)método é equivalente a usar um intervalo semi-aberto parcial como o subscrito da coleção. A notação subscrita é preferida prefix(upTo:).

# 4 Usando o prefix(through:)método

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 o removeSubrange(_:)método

Complexidade: O ( n ), em que n é o comprimento da coleção.

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 o dropLast(_:)método

Complexidade: O (1) se a coleção estiver em conformidade RandomAccessCollection; caso contrário, O ( k ), onde k é o número de elementos a serem descartados.

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

Uma solução diferente:

Uma solução em linha fácil que não trava se o seu array for muito curto

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

Mas funciona bem com isso.

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

Normalmente, isso falharia se você fizesse isso:

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

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

Para obter os 5 primeiros elementos de uma matriz, tudo o que você precisa fazer é dividir a matriz em questão. Na Swift, você fazê-lo como este: array[0..<5].

Para tornar a escolha dos N primeiros elementos de uma matriz um pouco mais funcional e generalizável, você pode criar um método de extensão para fazê-lo. Por exemplo:

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

Alterei levemente a resposta de Markus para atualizá-la para a versão mais recente do Swift, pois vardentro da sua declaração de método não há mais suporte:

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

Swift 4

Para obter os primeiros N elementos de uma matriz Swift, você pode usar prefix(_ maxLength: Int):

Array(largeArray.prefix(5))

Swift 4 com salvando tipos de array

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

Atualização para o swift 4:

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

Para o rápido 3:

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

Plain & Simple

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

Para uma matriz de objetos, você pode criar uma extensão a partir de Sequência.

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