所以我一直在用 Swift 的数组做一些实验。并通过以下代码发现了一些东西:

var shoppingList = ["Chocolate", "Bread", "Cheese", "Apple"]
println(shoppingList)
shoppingList[2..<2] = ["Butter", "Milk"] //Question #1 (Insert after 2nd element)
println(shoppingList)
shoppingList[0..<0] = ["Coffee"]
println(shoppingList)
shoppingList[7..<7] = ["Berry", "Pie"] //Question #2 (Append at the end of array)
println(shoppingList)

给出以下输出:

[Chocolate, Bread, Cheese, Apple]
[Chocolate, Bread, Butter, Milk, Cheese, Apple]
[Coffee, Chocolate, Bread, Butter, Milk, Cheese, Apple]
[Coffee, Chocolate, Bread, Butter, Milk, Cheese, Apple, Berry, Pie]

问题#1:试验 subscript语法，似乎使用 ..<将Insert数组中的一个项目到给定位置(在我的示例中，通过 [2..<2] 在第二个元素之后。与调用数组的 insert(_:atIndex:) 方法相反，这对性能有什么不同吗？或者取决于在这种情况下，可读性 只是使用 insert() 的好处吗？

问题#2:根据此处的 Swift 文档:Collection Type - See Modifying/Accessing Arrays

NOTE

You can’t use subscript syntax to append a new item to the end of an array.

那么我的问题是，为什么我能够使用 [7..<7] 将 2 个元素“Berry”和“Pie”附加到数组的末尾？ ？

在撰写本文时，我正在使用 Swift 1.2。

最佳答案

这看起来是个很好的问题，所以我试了一下。

查看使用 7..<7 订阅的示例，半开范围运算符 ..<正在创建 Range看起来像这样的结构:

let range = 7..<7
print(range.startIndex)    // 7
print(range.endIndex)      // 7

这也许是显而易见的。但是结束索引超出数组边界的范围对数组下标有什么影响？下标函数声明如下所示:

subscript (subRange: Range<Int>) -> ArraySlice<Element>

如果我们调用

let shoppingList = ["Coffee", "Chocolate", "Bread", "Butter", "Milk", "Cheese", "Apple"]
let item = shoppingList[6..<7]
// item: ArraySlice<Int> = "Apple"

我们得到了一片“Apple”，这是您所期望的——我们要了一片 shoppingList包含索引为 6 或更高的元素以及索引低于 7 的元素，因此我们返回一个包含索引 6 处的单个项目的切片。

另请注意此行为:

let item = shoppingList[6...6]
print(range.startIndex)    // 6
print(range.endIndex)      // 7

endIndex实际上是7 ，但是看看上面的下标，你不会期望有任何问题，你也不会得到任何问题。一种看待这个问题的方法是说 endIndex子范围的索引是要包含在数组切片中的第一个不数组元素的索引。考虑到这一点，我们可以假设下标实现边界检查。

那么这个下标的 getter 的实现是什么样的呢？让我们试试看:

extension Array {
    func myRangeSubscript(subRange: Range<Int>) -> ArraySlice<Element> {
        if count < subRange.endIndex { fatalError("Out of bounds!") } 

        var slice = ArraySlice<Element>()
        for i in subRange {
            slice.append(self[i])
        }
        return slice
    }
}

传入时7..<7 , 因为 x 不存在整数其中 7 >= x < 7 , for 循环不会被输入一次。这就解释了为什么 shoppingList[7..<7]有效，尽管乍一看索引超出范围。

考虑下标赋值可能是什么样子只是进一步的一小步:

subscript(subRange: Range<Int>) -> ArraySlice<Element> {
    get {
        //...
    }
    set(newElements) {
        // newElements: Array<Element> = []
        self.removeRange(subRange)
        var elementIndex = 0
        for i in subRange {
            self.insert(newElements[elementIndex++], atIndex: i)
        }
    }
}

尽管文档另有说明，但您显然可以“追加”到数组末尾的原因可能是，从语义上讲，您实际上并没有追加 - 您正在替换数组中的一系列元素一个新的元素数组。碰巧的是 n..<n范围，您将用新数组替换一个空 元素数组。从技术上讲，也许不是附加/插入，而是相当古怪的替换!因此，尽管文档在技术上可能是正确的，但实际上他们只是不考虑这种边缘情况。

简而言之，关于性能问题，我不能肯定地说下标实际上是如何实现的。但很明显，至少使用此范围下标执行插入所花费的时间与使用 insert(_:atIndex:) 所花费的时间一样长。或单个索引下标(无论如何很可能调用 insert(_:atIndex:))，因为在准备 ArraySlice 时可能有一些开销待创建，或调用 removeRange(_:) .

出于这个原因，以及它的可读性较差且无法在语义上反射(reflect)您要执行的操作这一事实，我会避免使用此范围下标来插入数组项。坚持使用 insert(_:atIndex:)或相应的下标 - 这就是它们的用途!

关于ios - 在 Swift 中修改数组，(通过下标语法插入和追加)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31872443/