logo标签列表

如何在Swift中迭代循环并获取索引和元素

arraysswiftenumeration
956

有没有一种函数可以用来迭代数组并同时获取索引和元素，就像Python的enumerate一样？

for index, element in enumerate(list):
    ...
20个回答
1956

是的。从Swift 3.0开始，如果您需要每个元素的索引和值，可以使用enumerated()方法来迭代数组。它返回一个序列，由数组中每个项目的索引和值组成的一对。例如：

for (index, element) in list.enumerated() {
  print("Item \(index): \(element)")
}

在Swift 2.0之后，Swift 3.0之前，该函数被称为enumerate()：

for (index, element) in list.enumerate() {
    print("Item \(index): \(element)")
}

在Swift 2.0之前，enumerate是一个全局函数。
for (index, element) in enumerate(list) {
    println("Item \(index): \(element)")
}
3
尽管它看起来像一个元组，在Swift 1.2中 - 不确定2.0版本 - enumerate返回一个EnumerateSequence<base: SequenceType>结构体。 - nstein
2
@Leviathlon 有明显或可测量的性能开销会有影响吗？不会。 - Dan Rosenstark
36
也许他们会在Swift 4中改为动名词形式enumerating。令人兴奋！ - Dan Rosenstark
3
@Honey 当使用 enumerated 时，for (index, element) in 是具有误导性的。应该改为 for (offset, element) in。 - Leo Dabus
3
我们是否要举行一个抽奖活动，看谁能猜出它下一步会变成什么。这个该死的语言就是不能静止不动，哈哈。 - Shayne
显示剩余2条评论
156

Swift 5 提供了一个名为 enumerated() 的方法，适用于 Array。 enumerated() 具有以下声明：

func enumerated() -> EnumeratedSequence<Array<Element>>

返回一系列的对（n，x），其中n表示从零开始的连续整数，x表示序列的一个元素。
在最简单的情况下，您可以使用 enumerated() 和 for 循环。例如：
let list = ["Car", "Bike", "Plane", "Boat"]
for (index, element) in list.enumerated() {
    print(index, ":", element)
}

/*
prints:
0 : Car
1 : Bike
2 : Plane
3 : Boat
*/
请注意，您不仅限于在for循环中使用enumerated()。实际上，如果您计划将enumerated()与for循环一起用于类似以下代码的内容，则行不通：
let list = [Int](1...5)
var arrayOfTuples = [(Int, Int)]()

for (index, element) in list.enumerated() {
    arrayOfTuples += [(index, element)]
}

print(arrayOfTuples) // prints [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]

一个更快的方法是：
let list = [Int](1...5)
let arrayOfTuples = Array(list.enumerated())
print(arrayOfTuples) // prints [(offset: 0, element: 1), (offset: 1, element: 2), (offset: 2, element: 3), (offset: 3, element: 4), (offset: 4, element: 5)]
作为替代方案，您也可以使用map和enumerated()函数：
let list = [Int](1...5)
let arrayOfDictionaries = list.enumerated().map { (a, b) in return [a : b] }
print(arrayOfDictionaries) // prints [[0: 1], [1: 2], [2: 3], [3: 4], [4: 5]]
此外，尽管它有一些限制，forEach可以很好地替代for循环：
let list = [Int](1...5)
list.reversed().enumerated().forEach { print($0, ":", $1) }

/*
prints:
0 : 5
1 : 4
2 : 3
3 : 2
4 : 1
*/
通过使用 enumerated() 和 makeIterator()，您甚至可以手动迭代您的 Array。例如：
import UIKit
import PlaygroundSupport

class ViewController: UIViewController {

    var generator = ["Car", "Bike", "Plane", "Boat"].enumerated().makeIterator()

    override func viewDidLoad() {
        super.viewDidLoad()

        let button = UIButton(type: .system)
        button.setTitle("Tap", for: .normal)
        button.frame = CGRect(x: 100, y: 100, width: 100, height: 100)
        button.addTarget(self, action: #selector(iterate(_:)), for: .touchUpInside)
        view.addSubview(button)
    }

    @objc func iterate(_ sender: UIButton) {
        let tuple = generator.next()
        print(String(describing: tuple))
    }

}

PlaygroundPage.current.liveView = ViewController()

/*
 Optional((offset: 0, element: "Car"))
 Optional((offset: 1, element: "Bike"))
 Optional((offset: 2, element: "Plane"))
 Optional((offset: 3, element: "Boat"))
 nil
 nil
 nil
 */
1
使用enumerate的唯一好处是获取索引吗？ - mfaani
59

从Swift 2开始，需要在集合上调用enumerate函数，如下所示：

for (index, element) in list.enumerate() {
    print("Item \(index): \(element)")
}
54

我在寻找使用字典(Dictionary)的方法时找到了这个答案, 原来将其适配很容易, 只需要为该元素传递一个元组即可。

// Swift 2

var list = ["a": 1, "b": 2]

for (index, (letter, value)) in list.enumerate() {
    print("Item \(index): \(letter) \(value)")
}
45

Swift 5.x:

let list = [0, 1, 2, 3, 4, 5]

list.enumerated().forEach { (index, value) in
    print("index: \(index), value: \(value)")
}

或者，

list.enumerated().forEach { 
    print("index: \($0.offset), value: \($0.element)")
}

或者，

for (index, value) in list.enumerated() {
    print("index: \(index), value: \(value)")
}
35

为了完整性，您可以简单地遍历数组索引并使用下标来访问相应索引处的元素：

let list = [100,200,300,400,500]
for index in list.indices {
    print("Element at:", index, " Value:", list[index])
}

使用forEach

list.indices.forEach {
    print("Element at:", $0, " Value:", list[$0])
}

使用集合enumerated()方法。请注意，它返回一个由offset和element组成的元组集合：

for item in list.enumerated() {
    print("Element at:", item.offset, " Value:", item.element)
}

使用forEach:

list.enumerated().forEach {
    print("Element at:", $0.offset, " Value:", $0.element)
}

这些将会被打印：

索引为0的元素 值: 100

索引为1的元素 值: 200

索引为2的元素 值: 300

索引为3的元素 值: 400

索引为4的元素 值: 500

如果你需要数组的索引（而不是偏移量）以及其元素，你可以扩展Collection并创建自己的方法来获取索引的元素：

extension Collection {
    func indexedElements(body: ((index: Index, element: Element)) throws -> Void) rethrows {
        var index = startIndex
        for element in self {
            try body((index,element))
            formIndex(after: &index)
        }
    }
}

另一个可能的实现方式是由Alex建议的，即将集合索引与其元素一起压缩：

extension Collection {
    func indexedElements(body: ((index: Index, element: Element)) throws -> Void) rethrows {
        for element in zip(indices, self) { try body(element) }
    }
    var indexedElements: Zip2Sequence<Indices, Self> { zip(indices, self) }
}

测试：

let list =  ["100","200","300","400","500"]

// You can iterate the index and its elements using a closure
list.dropFirst(2).indexedElements {
    print("Index:", $0.index, "Element:", $0.element)
}

// or using a for loop
for (index, element) in list.indexedElements  {
    print("Index:", index, "Element:", element)
}

这将打印

索引：2 元素：300

索引：3 元素：400

索引：4 元素：500

索引：0 元素：100

索引：1 元素：200

索引：2 元素：300

索引：3 元素：400

索引：4 元素：500

顺便提一下，您可以通过使用“zip（self.indices，self）”循环实现“enumeratedIndices”。 - Alexander
@Alexander-ReinstateMonica for element in zip(indices, self) { try body(element) }. 顺便说一下，我不喜欢我选择的命名方式，indexedElements 可能更好地描述了它的功能。 - Leo Dabus
哦，我认为这是一个更好的名称。是的，for循环可以工作，但也可以使用zip(self.indices, self).forEach(body)。 - Alexander
@Alexander-ReinstateMonica forEach 在幕后使用 for 循环。我更喜欢保持简单明了。https://github.com/apple/swift/blob/master/stdlib/public/core/Sequence.swift @inlinable public func forEach( _ body: (Element) throws -> Void ) rethrows { for element in self { try body(element) } } } - Leo Dabus
1
在列表索引中使用list.indices非常棒 @LeoDabus !!!!!!!!!!!!!!!! - Fattie
34

Swift 5.x：

我个人更喜欢使用forEach方法：

list.enumerated().forEach { (index, element) in
    ...
}

您也可以使用简短的版本：

list.enumerated().forEach { print("index: \($0.0), value: \($0.1)") }
forEach不能返回值，这是一个有趣的小知识点 - 在void函数中出现了意外的非void返回值。因此，需要在函数执行后返回结果。 - Meep
2
如果需要，您也无法跳过循环。 - CyberMew
24
您可以使用枚举的循环来获得您想要的结果： Swift 2:
for (index, element) in elements.enumerate() {
    print("\(index): \(element)")
}

Swift 3 & 4：

for (index, element) in elements.enumerated() {
    print("\(index): \(element)")
}

或者你可以通过一个for循环来得到相同的结果：

for index in 0..<elements.count {
    let element = elements[index]
    print("\(index): \(element)")
}

希望有所帮助。

18

基本枚举

for (index, element) in arrayOfValues.enumerate() {
// do something useful
}

或者使用Swift 3...

for (index, element) in arrayOfValues.enumerated() {
// do something useful
}

枚举、过滤和映射

然而，我最常使用enumerate与map或filter结合使用。例如，在操作多个数组时。

在这个数组中，我想要过滤奇数或偶数索引的元素，并将它们从整数转换为双精度浮点数。所以enumerate()获取了索引和元素，然后通过filter检查索引，最后为了摆脱生成的元组，我将其映射到仅仅是元素。

let evens = arrayOfValues.enumerate().filter({
                            (index: Int, element: Int) -> Bool in
                            return index % 2 == 0
                        }).map({ (_: Int, element: Int) -> Double in
                            return Double(element)
                        })
let odds = arrayOfValues.enumerate().filter({
                            (index: Int, element: Int) -> Bool in
                            return index % 2 != 0
                        }).map({ (_: Int, element: Int) -> Double in
                            return Double(element)
                        })
12

使用.enumerate()方法是可行的，但它并不提供元素的真实索引；它只提供一个从0开始递增1的整数。这通常是无关紧要的，但在与ArraySlice类型一起使用时可能会导致意外行为。看下面的代码：

let a = ["a", "b", "c", "d", "e"]
a.indices //=> 0..<5

let aSlice = a[1..<4] //=> ArraySlice with ["b", "c", "d"]
aSlice.indices //=> 1..<4

var test = [Int: String]()
for (index, element) in aSlice.enumerate() {
    test[index] = element
}
test //=> [0: "b", 1: "c", 2: "d"] // indices presented as 0..<3, but they are actually 1..<4
test[0] == aSlice[0] // ERROR: out of bounds

这是一个有些牵强的例子，在实践中并不常见，但我认为了解这一点仍然很值得。

2
它实际上并没有提供元素的真实索引；它只提供一个从0开始递增1的Int，用于每个连续的元素。是的，这就是为什么它被称为enumerate。此外，切片不是数组，因此它的行为不同也就不足为奇了。这里没有错误 - 一切都是按设计来的。 :) - Eric Aya
5
没错，但我从未称其为 bug。它只是一种可能出现的意外行为，我认为值得提醒那些不知道它如何与 ArraySlice 类型产生负面影响的人们。 - Cole Campbell
你知道如何获取实际元素的索引吗？例如，如果首先使用filter。 - Alexandre Cassagne
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接