这对我有用:

var test = [1, 2, 3]
var n = 2
var test2 = test[0..<n]

您的问题可能在于如何从一开始就声明数组。

编辑:

要修复函数，必须将 Slice强制转换为数组:

func aFunction(numbers: Array<Int>, position: Int) -> Array<Int> {
var newNumbers = Array(numbers[0..<position])
return newNumbers
}


// test
aFunction([1, 2, 3], 2) // returns [1, 2]

使用带有 range 的 Array下标

和 Swift 5一起，当你写..。

let newNumbers = numbers[0...position]

... newNumbers不是 Array<Int>型，而是 ArraySlice<Int>型。这是因为 Array的 subscript(_:​)返回一个 ArraySlice<Element>，根据苹果公司的说法，这个 ArraySlice<Element>显示了一些较大数组的存储视图。

此外，Swift 还为 Array提供了一个名为 init(_:​)的初始化器，它允许我们从 sequence(包括 ArraySlice)创建一个新的数组。

因此，您可以将 subscript(_:​)与 init(_:​)一起使用，以便从一个数组的第一个 N元素中获得一个新数组:

let array = Array(10...14) // [10, 11, 12, 13, 14]
let arraySlice = array[0..<3] // using Range
//let arraySlice = array[0...2] // using ClosedRange also works
//let arraySlice = array[..<3] // using PartialRangeUpTo also works
//let arraySlice = array[...2] // using PartialRangeThrough also works
let newArray = Array(arraySlice)
print(newArray) // prints [10, 11, 12]

2. 使用 Array的 prefix(_:)方法

Swift 为符合 Collection协议(包括 Array)的类型提供了一个 prefix(_:)方法:

func prefix(_ maxLength: Int) -> ArraySlice<Element>

返回包含初始元素的子序列，最大长度为 maxLlength。

苹果还表示:

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

因此，作为前一个示例的替代方案，您可以使用以下代码从另一个数组的第一个元素创建一个新数组:

let array = Array(10...14) // [10, 11, 12, 13, 14]
let arraySlice = array.prefix(3)
let newArray = Array(arraySlice)
print(newArray) // prints [10, 11, 12]

下标

extension Array where Element : Equatable {
public subscript(safe bounds: Range<Int>) -> ArraySlice<Element> {
if bounds.lowerBound > count { return [] }
let lower = Swift.max(0, bounds.lowerBound)
let upper = Swift.max(0, Swift.min(count, bounds.upperBound))
return self[lower..<upper]
}
  

public subscript(safe lower: Int?, _ upper: Int?) -> ArraySlice<Element> {
let lower = lower ?? 0
let upper = upper ?? count
if lower > upper { return [] }
return self[safe: lower..<upper]
}
}

返回夹在给定限制范围内的此范围的副本。

var arr = [1, 2, 3]
    

arr[safe: 0..<1]    // returns [1]  assert(arr[safe: 0..<1] == [1])
arr[safe: 2..<100]  // returns [3]  assert(arr[safe: 2..<100] == [3])
arr[safe: -100..<0] // returns []   assert(arr[safe: -100..<0] == [])


arr[safe: 0, 1]     // returns [1]  assert(arr[safe: 0, 1] == [1])
arr[safe: 2, 100]   // returns [3]  assert(arr[safe: 2, 100] == [3])
arr[safe: -100, 0]  // returns []   assert(arr[safe: -100, 0] == [])

使用 extension和参数名 range的另一个变体

此扩展使用 Range和 ClosedRange

extension Array {


subscript (range r: Range<Int>) -> Array {
return Array(self[r])
}




subscript (range r: ClosedRange<Int>) -> Array {
return Array(self[r])
}
}

测试:

func testArraySubscriptRange() {
//given
let arr = ["1", "2", "3"]


//when
let result = arr[range: 1..<arr.count] as Array


//then
XCTAssertEqual(["2", "3"], result)
}


func testArraySubscriptClosedRange() {
//given
let arr = ["1", "2", "3"]


//when
let result = arr[range: 1...arr.count - 1] as Array


//then
XCTAssertEqual(["2", "3"], result)
}

数组函数方式:

   array.enumerated().filter { $0.offset < limit }.map { $0.element }

范围:

 array.enumerated().filter { $0.offset >= minLimit && $0.offset < maxLimit }.map { $0.element }

这种方法的优点是这样的实现是安全的。