Arrays 索引范围中的新数组

我怎么能做这样的事？从数组中获取前n个元素：

newNumbers = numbers[0..n]

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]

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]

当前正在获取以下错误：

error: could not find an overload for 'subscript' that accepts the supplied arguments

编辑：

这是我正在使用的函数

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

func函数（数字：数组，位置：Int）->Array{
var newNumbers=编号[0…位置]
返回新号码
}

这对我很有用：

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

#1.使用带范围的

数组
下标
用Swift 5，当你写作时

let newNumbers = numbers[0...position]

…
newNumbers
不是类型
Array
，而是类型
ArraySlice
。这是因为
Array
返回一个
ArraySlice
，据苹果公司称，它显示了某个较大阵列的存储视图

此外，Swift还提供了
数组
一个名为的初始值设定项，允许我们从
序列
创建一个新数组（包括
ArraySlice
）

因此，您可以使用
下标​)带有
init（\ux:​)
为了从数组的前n个元素中获取新数组：

newNumbers = numbers[0..n]

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]

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]

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

苹果公司还声明：

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

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

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]

下标
扩展数组，其中元素：equalable{
公共下标（安全界限：范围）->ArraySlice{
如果bounds.lowerBound>count{return[]}
let lower=Swift.max（0，bounds.lowerBound）
设上限=Swift.max（0，Swift.min（计数，界限，上限））
返回自[下..阵列片{
设下限=下限？？0
设上限=上限？？计数
如果下限>上限{return[]}
返回self[safe:lower..使用扩展名
和参数名
范围

extension Array {

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


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

此扩展使用
范围
和
关闭范围

extension Array {

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


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

扩展数组{
下标（范围r:范围）->数组{
返回数组（self[r]）
}
下标（范围r:ClosedRange）->数组{
返回数组（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)
}

func testArraySubscriptRange（）{
//给定
设arr=[“1”、“2”、“3”]
//什么时候
让结果=arr[范围：1..阵列功能方式：

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

array.enumerated（）.filter{$0.offset

范围：

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

array.enumerated（）.filter{$0.offset>=minLimit&&$0.offset

这种方法的优点是这样的实现是安全的。
我在问题中添加了更多的上下文，我在一个函数中工作。这是独立的，但不是在函数中。很好！干杯-这很有效。我会在允许的时候接受答案。迂腐的观点，但这并不是真正将
片段
转换为
一个rray
，而是从切片创建一个新数组。强制转换将使用
作为
运算符：
数字作为数组
，这将导致错误。语言已更改，它使用三个省略号，而不是两个点
。
更改为
。请为答案添加一些说明。回答很好。我想知道的是什么t本质上是将一个ArraySlice强制转换为一个数组。就个人而言，我不会包含那么多断言。因为我通常希望如果我提供错误的范围等，slice会失败。为了完整性，
Array
还有一个
后缀
方法，该方法与此处显示的
前缀
方法类似。