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

在Swift中，是否有一种聪明的方法可以使用数组上的高阶方法返回前5个对象？ obj-c的方法是保存一个索引，for通过数组循环递增索引，直到索引为5，然后返回新数组。有没有办法通过

过滤器

、

映射

或

减少

？更新： 现在可以使用

前缀
获取数组的前n个元素。查看有关如何使用前缀的说明

原始答案：
只需返回数组的一个范围，您就可以轻松地执行此操作，而无需使用
过滤器
、
映射
或
减少
：

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

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

var wholeArray=[1,2,3,4,5,6]
变量n=5
var firstFive=wholeArray[0..要获取数组的前5个元素，只需对相关数组进行切片即可{
如果（元素计数>计数）{
elementCount=计数
}
返回数组（self[0..到目前为止，获取Swift数组前N个元素的最简单的方法是使用
前缀（uMaxLength:Int）
：

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

注意：正如注释中指出的，
Array.prefix
实际上返回一个
ArraySlice
，而不是
数组
。在大多数情况下，这不会有什么区别，但如果需要将结果分配给
数组
类型或将其传递给需要
数组
参数的方法，则需要强制执行result进入一个
数组
类型：
让first5=Array（someArray.prefix（5））
我稍微更改了Markus的答案，将其更新为最新的Swift版本，因为不再支持方法声明中的
var
：

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

扩展数组{
func takeElements（elementCount:Int）->数组{
如果（元素计数>计数）{
返回数组（self[0..SWIFT 4

另一种解决方案：

一个简单的内联解决方案，在阵列太短时不会崩溃

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

swift 4的更新：

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

[0,1,2,3,4,5].enumerated（）.compactMap{$0<10000？$1:nil}

对于swift 3：

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

[0,1,2,3,4,5].enumerated（）.flatMap{$0<10000？$1:nil}
使用Swift 5，根据您的需要，您可以选择以下6个操场代码之一，以解决您的问题


#1.使用
下标（:）
下标
苹果公司声明前缀（:）
：

如果最大长度超过集合中的元素数，则结果将包含集合中的所有元素

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

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


#3.使用
前缀（最多：）
方法
复杂性：O（1）

苹果公司声明前缀（最多：）
：

使用
前缀（最多：）
方法相当于使用部分半开范围作为集合的下标。下标表示法优于
前缀（最多：）


#4.使用
前缀（通过：）
方法

#5.使用
removeSubrange（:）
方法
复杂性：O（n），其中n是集合的长度

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

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（:）
方法
复杂性：如果集合符合
RandomAccessCollection
，则为O（1）；否则为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"]

Swift 4保存数组类型

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

扩展数组{
func take（uElementsCount:Int）->[元素]{
设min=Swift.min（elementscont，count）
返回数组（self[0..普通和简单

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

扩展数组{
func first（elementCount:Int）->数组{
设min=Swift.min（elementCount，count）
返回数组（self[0..对于对象数组，可以从序列创建扩展

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

Swift 4

要获取Swift数组的前N个元素，可以使用
前缀（\umaxlength:Int）
：

Prefix函数无疑是解决此问题的最有效方法，但您也可以使用类似以下的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.")
}

let数组=[1,2,3,4,5,6,7,8,9]
设maxNum=5
var iterationNumber=0
var firstNumbers=[Int（）]
如果array.count>maxNum{
对于数组中的i{
迭代次数+=1
如果iterationNumber如果只需要Swift数组中的第一个
n
项，则可以执行
wholeArray.prefix（n）
具有边界安全的额外好处。如果
n
大于数组大小
前缀
将返回整个数组。如果
wholeArray
没有比
n
@Crashalot更多的元素，它将崩溃。我不完全确定，但我认为在我编写答案的时候，没有这样的错误使用此代码获取前5个对象…这非常有效[0,1,2,3,4,5]。enumerated（）.flatMap{$0<5？$1:nil}+1这样一个坏名字的选择，IMHO。数组有
dropFirst
和
dropLast
，所以最好有
takeFirst
和
takeLast
。另外，如果你需要
first5
作为数组，只需写
让first5=Array（someArray.prefix（5））
@mluisbrown抱歉，不能同意你：）在我的项目中，Xcode 7.2中的前缀（5）
导致编译错误
无法将类型“ArraySlice”的值赋给类型“[video]”
video=Array（video.prefix（5））
@onmyway133
前缀
可能只是Swift 2.x（我不记得它是否在1.x中），但它肯定存在于任何支持Swift 2.x（即iOS 7及更高版本）的操作系统中。Swift功能可用性由Swift发行版决定，而不是由iOS版本决定。对于swift3
[0,1,2,3,4,5]。enumerated（）
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"]

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

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

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

Array(largeArray.prefix(5))

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.")
}