如何在Swift中返回数组的前5个对象?

在Swift中，是否有一种聪明的方法来使用数组上的高阶方法来返回5个第一个对象? obj-c的方法是保存一个索引，而for-loop则通过数组将索引值递增到5，然后返回新的数组。有没有办法用filter， map或reduce来做到这一点?< / p >
150009 次浏览
小开

不需要filter、map、reduce或prefix，只需通过下标返回数组的一个范围即可:

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


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


let firstFiveArray = Array(firstFiveSlice)
小开

为了获取数组的前5个元素，你所需要做的就是对数组进行切片。在Swift中，你这样做:array[0..<5]。

为了使选择数组的前N个元素更具功能性和可泛化性，您可以创建一个扩展方法来执行此操作。例如:

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

到目前为止，获取Swift数组的前N个元素的最简洁的方法是使用prefix(_ maxLength: Int):

let array = [1, 2, 3, 4, 5, 6, 7]
let slice5 = array.prefix(5) // ArraySlice
let array5 = Array(slice5)   // [1, 2, 3, 4, 5]

一句话是:

let first5 = Array(array.prefix(5))

这样做的好处是边界安全。如果传递给prefix的计数大于数组计数，则它只返回整个数组。

注意:正如评论中指出的，Array.prefix实际上返回ArraySlice，而不是Array。

如果需要将结果赋值给Array类型或将其传递给期望Array参数的方法，则需要将结果强制转换为Array类型:let first5 = Array(array.prefix(5))

小开 
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]
小开

我稍微改变了Markus的答案，将其更新为最新的Swift版本，因为你的方法声明中的var不再受支持:

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

斯威夫特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
小开

在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"]
小开

斯威夫特4保存数组类型

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

平原,简单的

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

对于对象数组，您可以从Sequence创建一个扩展。

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

斯威夫特4

要获取Swift数组的前N个元素，可以使用prefix(_ maxLength: Int):

Array(largeArray.prefix(5))
小开

Prefix函数绝对是解决这个问题的最有效的方法，但是你也可以像下面这样使用for-in循环:

let array = [1,2,3,4,5,6,7,8,9]
let maxNum = 5
var iterationNumber = 0
var firstNumbers = [Int()]
if array.count > maxNum{
for i in array{
iterationNumber += 1
if iterationNumber <= maxNum{
firstNumbers.append(i)
}
}
firstNumbers.remove(at: 0)
print(firstNumbers)
} else {
print("There were not \(maxNum) items in the array.")
}
这个解决方案占用了很多行代码，但是检查数组中是否有足够的项来执行程序，然后继续并解决了问题。 这个解决方案使用了许多基本函数，包括array.count，它返回数组不是数组中最后一项的位置中项目的数量。它还使用array.append，将元素添加到数组的末尾。最后，它使用array.remove，它删除数组中具有指定位置的项

我已经测试过了，它至少适用于swift 5。

小开

接这个分机。它修复了原来可怕的命名:

public extension Array {
func first(_ count: Int) -> ArraySlice<Element> {
return self.prefix(count)
}
    

func last(_ count: Int) -> ArraySlice<Element> {
return self.suffix(count)
}
}

用法:

someArr.first(5)
someArr.last(5)

提交答案