Swift 中的 Sequence（一）

发表于 | 分类于 | | 阅读次数: |
字数统计: 12k | 阅读时长 ≈ 12 mins.

Swift 是一门可以让你按照自己喜欢的方式写代码的语言，它有很强的扩展能力，而它众多的 Collection Protocols 则是这种扩展能力的提供者之一。

本文介绍一下 Sequence 和 Iterator 的基本概念，及如何实现一个 Sequence。

撰写本文时的 Swift 版本是 Swift 3.1。

Sequence

Sequence 是一系列相同类型的值的集合，并且提供对这些值的迭代能力。

迭代一个 Sequence 最常见的方式就是 for-in 循环，如下：

1
2
3
for element in someSequence {
    doSomething(with: element)
}

我们经常把 for-in 循环用在 Array、Dictioanry、Set 等数据结构上，因为他们都实现了 Sequence 协议。

Sequence 协议的定义：

1
2
3
4
protocol Sequence {
    associatedtype Iterator: IteratorProtocol
    func makeIterator() -> Iterator
}

Sequence 协议只有一个必须实现的方法 makeIterator()

makeIterator() 需要返回一个 Iterator，它是一个 IteratorProtocol 类型。

也就是说只要提供一个 Iterator 就能实现一个 Sequence，那么 Iterator 又是什么呢？

Iterator

Iterator 在 Swift 3.1 标准库中即为 IteratorProtocol，它用来为 Sequence 提供迭代能力。对于 Sequence，我们可以用 for-in 来迭代其中的元素，其实 for-in 的背后是 IteratorProtocol 在起作用。

IteratorProtocol 的定义如下：

1
2
3
4
public protocol IteratorProtocol {
    associatedtype Element
    public mutating func next() -> Self.Element?
}

其中仅声明了一个 next() 方法，用来返回 Sequence 中的下一个元素，或者当没有下一个元素时返回 nil。
associatedtype 声明了元素的类型。

举个例子，创建一个动物的数组，对齐进行循环遍历：

1
2
3
4
5
6
7
8
9
let animals = ["Antelope", "Butterfly", "Camel", "Dolphin"]
for animal in animals {
    print(animal)
}
// 打印结果：
Antelope
Butterfly
Camel
Dolphin

实际上编译器会把以上代码转换成下面的代码：

1
2
3
4
var animalIterator = animals.makeIterator()
while let animal = animalIterator.next() {
    print(animal)
}
  1. 获取到 animals 数组的 Iterator
  2. 在一个 while 循环中，通过 Iterator 不断获取下一个元素，并对元素进行操作
  3. 当 next() 返回 nil 时，退出循环

Iterator 实现举例

举例1：最简单的 Iterator

最简单的 Iterator 实现就是在 next() 中返回 nil，代码如下：

1
2
3
4
5
6
struct SimplestIterator: IteratorProtocol {
    typealias Element = Int
    mutating func next() -> Int? {
        return nil
    }
}

这时这个 Iterator 不会迭代出任何元素，确切的说，这个 Interator 在迭代时仅调用一次 next() 就结束了。

举例2：常量 Iterator

让 next() 返回一个值，也是一种简单的实现，例如下面代码：

1
2
3
4
5
6
struct ConstantIterator: IteratorProtocol {
    typealias Element = Int
    mutating func next() -> Int? {
        return 1
    }
}

上面这个例子实现了一个只返回 1 的 Iterator。

举例3：斐波那契数列 Iterator

再看一个复杂一点的例子，斐波那契数列的实现：

1
2
3
4
5
6
7
8
struct FibsIterator: IteratorProtocol {
    var state = (0, 1)
    mutating func next() -> Int? {
        let upcomingNumber = state.0
        state = (state.1, state.0 + state.1)
        return upcomingNumber
    }
}
  1. state 具有一个初始值 (0, 1)，用元组表示
  2. 每次调用 next() 时，返回 state 元组中的第一个元素，然后更新 state 为 （第二个元素的值，第一个元素 + 第二个元素的和）

在实现 Iterator 时可以省略 Element 的类型声明，Swift 会通过 next() 的返回值类型来自动推导出 Element 的类型。不过对于实现比较复杂的 Iterator，往往还是会加上类型声明这一句，提高代码可读性。

实现一个 Sequence

实现一个 Sequence 首先要实现一个 Iterator。

我们准备实现这样的一个 Iterator：它接收一个字符串数组，并可以迭代这个数组中所有字符串的首字母。
当数组中的最后一个字符串迭代完毕后，退出迭代。

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct FirstLetterIterator: IteratorProtocol {
    let strings: [String]
    var offset: Int
	
    init(strings: [String]) {
        self.strings = strings
        offset = 0
    }
	
    mutating func next() -> String? {
        guard offset < strings.endIndex else { return nil }
        let string = strings[offset]
        offset += 1
        return string.substring(to: string.index(string.startIndex, offsetBy: 1))
    }
}
  1. 这个 Iterator 的需要输入一个字符串数组
  2. 在 next() 中，判断边界，并返回数组中索引为 offset 的字符串的首字母，并把 offset 加 1

这里省去了 Element 类型的声明，编译器可以根据 next() 的返回值类型推断出 Element 的类型。

有了已经实现好的 Iterator，就可以很简单的用它实现 Sequence，在 makeIterator() 中返回这个 Iterator 即可。

1
2
3
4
5
6
7
struct FirstLetterSequence: Sequence {
    let strings: [String]
	
    func makeIterator() -> FirstLetterIterator {
        return FirstLetterIterator(strings: strings)
    }
}

现在 Sequence 已经实现好了，可以测试一下效果。
我们可以创建一个 FirstLetterSequence，并用 for-in 循环对其迭代：

1
2
3
4
5
6
7
8
for letter in FirstLetterSequence(strings: ["apple", "banana", "orange"]) {
    print(letter)
}
/* 打印结果：
a
b
o
*/

结果为打印出了数组中每个字符串的首字母。

参考资料