一、概念
官方解释
Iterator: A type that supplies the values of a sequence one at a time. The IteratorProtocol protocol is tightly linked with the Sequenceprotocol. Sequences provide access to their elements by creating an iterator, which keeps track of its iteration process and returns one element at a time as it advances through the sequence.
Sequence: A type that provides sequential, iterated access to its elements.
拙劣的翻译
Iterator: 一次只提供序列中一个元素的类型。迭代器协议和 Sequence协议紧密相连。序列通过创建一个迭代器来访问其中的元素，而迭代器在遍历序列的时候负责记录迭代过程和依次输出元素
Sequence: 提供对其中元素的顺序、迭代访问的类型。
二、协议一览表
IteratorProtocol
public protocol IteratorProtocol {
/// The type of element traversed by the iterator.
associatedtype Element
/// - Returns: The next element in the underlying sequence, if a next element
/// exists; otherwise, `nil`.
public mutating func next() -> Self.Element?
}
Sequence
Sequence协议里面的内容有点多，稍微进行了删减，保留实现此协议最少需求。查看完整协议代码，请查看最后的参考文档。
//遵守Sequence协议需要的最少要求
public protocol Sequence {
/// A type representing the sequence's elements.
associatedtype Element where Self.Element == Self.Iterator.Element, Self.Iterator.Element == Self.SubSequence.Element, Self.SubSequence.Element == Self.SubSequence.Iterator.Element
/// A type that provides the sequence's iteration interface and
/// encapsulates its iteration state.
associatedtype Iterator : IteratorProtocol
/// Returns an iterator over the elements of this sequence.
public func makeIterator() -> Self.Iterator
}
注意点
- 迭代器是单向结构，只能按增加的方向前进，不能倒退或重置
- 迭代器协议中的
associatedtype Element不一定要实现，它可以根据next()方法的返回值进行推断 - 迭代器协议 next()方法的修饰符mutating 不一定必须，要看实现它的是类还是结构体，对于结构体，如果迭代器没有保存的状态那么就可以不用写，否则必须加上。但是从系统的设计中可以看到协议方法都用了mutating ，就是为了兼容类、结构体等类型。
三、案例剖析
1、当我们利用for_in 对序列进行遍历的时候，其实内部就是利用的迭代器进行遍历。平时的使用中很少利用迭代器遍历，因为它不符合语言习惯。
符合语言习惯的迭代：
let animals = ["Antelope", "Butterfly", "Camel", "Dolphin"]
for animal in animals {
print(animal)
}
利用迭代器进行迭代：
while let animal = animalIterator.next() {
print(animal)
}
利用迭代器的案例
先看下正常的reduce使用
//必须要有一个初始值，在这里初始值是 0
[1,2,3].reduce(0) { (first, second) -> Int in
first + second
}
注意点：
- 原始的reduce方法必须要有一个初始值
下面是用来扩展一个reduce方法
extension Sequence {
func reduce1(_ nextPartialResult: (Element, Element) -> Element) -> Element? {
var i = makeIterator()
//利用迭代器先产生一个初始值，相当于reduce的初始值在内部实现了
guard var accumulated = i.next() else {
return nil
}
//利用产生的初始值，进行接下来的操作
while let element = i.next() {
accumulated = nextPartialResult(accumulated, element)
}
return accumulated
}
}
let longestAnimal = animals.reduce1 { current, element in
if current.count > element.count {
return current
} else {
return element
}
}
print("=======>迭代器实现reduce")
print(longestAnimal)
2、倒计时案例
struct Countdown: Sequence {
let start: Int //倒计时数
func makeIterator() -> CountdownIterator {
return CountdownIterator(self)
}
}
struct CountdownIterator: IteratorProtocol {
let countdown: Countdown
var times = 0 //保存迭代次数,也相当于保存的迭代器状态
init(_ countdown: Countdown) {
self.countdown = countdown
}
//倒计时等于0的时候返回nil，迭代状态结束
mutating func next() -> Int? {
let nextNumber = countdown.start - times
guard nextNumber > 0 else { return nil }
times += 1
return nextNumber
}
}
print("=======>倒计时")
let threeTwoOne = Countdown(start: 3)
for count in threeTwoOne {
print("\(count)...")
}
注意点：
- 倒计时案例中没有实现 IteratorProtocol中的
associatedtype Element，所以会根据next()方法的返回值类型而自动推断出为Int - 如果是类实现了IteratorProtocol协议，那么对于next()方法的mutating 修饰符可以省略， 这个只能结构体或枚举有效。
3、序列反转
class ReverseIterator<T>: IteratorProtocol {
typealias Element = T
var array: [Element]
var currentIndex = 0
init(array:[Element]) {
self.array = array
currentIndex = array.count - 1
}
//对于类, mutating 这个是不必须的
func next() -> Element? {
if currentIndex < 0 {
return nil
} else {
let element = self.array[currentIndex]
currentIndex -= 1
return element
}
}
}
struct ReverseSequence<T>: Sequence {
var array:[T]
init(array:[T]) {
self.array = array
}
typealias Iterator = ReverseIterator<T>
func makeIterator() -> ReverseSequence.Iterator {
return ReverseIterator(array: array)
}
}
let array = [1, 2, 3, 4]
for num in ReverseSequence(array: array) {
print(num)
}
注意点
- 进行了泛型操作，所以实现了
associatedtype Element - 对于类没有用mutating修饰next()方法
四、迭代器的值语义
Swift标准库的迭代器大部分都是值语义。那么它就具有值语义的一些特性，如果将迭代器进行复制，那么将得到两份不同的迭代器。
- 普通的集合类型迭代器的值语义
let animals = ["Antelope", "Butterfly", "Camel", "Dolphin"]
var a1 = animals.makeIterator()
print(a1.next() ?? "") // Antelope
print(a1.next() ?? "") // Butterfly
//a2复制了当前的a1状态
var a2 = a1
print(a1.next() ?? 0) //Camel
print(a1.next() ?? 0) //Dolphin
//上下打印的数据一致
print(a2.next() ?? 0) //Camel
print(a2.next() ?? 0) //Dolphin
- stride迭代器的值语义
let seq = stride(from: 0, to: 10, by: 1)
var i1 = seq.makeIterator()
print(i1.next() ?? 0) //0
print(i1.next() ?? 0) //1
//i2复制了当前的i1状态
var i2 = i1
print(i1.next() ?? 0) //2
print(i1.next() ?? 0) //3
//上下打印的数据一致
print(i2.next() ?? 0) //2
print(i2.next() ?? 0) //3
stride注意点
- stride可产生一个序列
- stride函数可以应用于任何遵守了
Strideable协议的类型 - stride(from: 3, to: 0, by: -1) 产生【3，2，1】序列
- stride(from: 0, to: 10, by: -1) 不会产生序列
五、迭代器的引用语义
//实现一个结构体遵守迭代器协议
struct FibsIterator: IteratorProtocol {
var fibSequence = (0, 1)
//显式指明元素类型，也可不写，自动推断，显式指明类型在多协议中有助于理解
typealias Element = Int
//实现无限循环，但中间部分加了个判断，终止循环
mutating func next() -> Int? {
fibSequence = (fibSequence.1, fibSequence.0 + fibSequence.1)
//实现100以内的斐波那契数列
guard fibSequence.1 < 100 else {
return nil
}
return fibSequence.1
}
}
//在创建原始迭代器的时候直接用AnyIterator进行包裹，这样对custom的复制都是引用类型
let custom = AnyIterator(FibsIterator())
//原始迭代器先next两次
let _ = custom.next() //1
let _ = custom.next() //2
let copyIterator = custom
print("原始迭代器执行结果：\(custom.next()!)") //3
print("复制迭代器执行结果：\(copyIterator.next()!)") //5
注意点
- A type-erased iterator of Element. AnyIterator是一个消除原来迭代器类型的迭代器，也就是说AnyIterator不具有值语义
- custom和copyIterator引用的是同一个迭代器
六、序列是不保证稳定的
“序列并不只限于像是数组或者列表这样的传统集合数据类型。像是网络流，磁盘上的文件，UI 事件的流，以及其他很多类型的数据都可以使用序列来进行建模。但是这些都和数组不太一样，对于数组，你可以多次遍历其中的元素，而上面这些例子中你并非对所有的序列都能这么做”
摘录来自: Chris Eidhof. “Swift 进阶。”
最后一张图总结下
图片.png
参考文档：
IteratorProtocol
Sequence
