我们知道在 Swift 中 Sequence 是 集合类型结构 中的基础。而在 Sequence 协议的定义当中我们可以看到有这么一句代码 ：
associatedtype Iterator : IteratorProtocol
我们看到有两个关键字：associatedtype 与 IteratorProtocol
1.associatedtype
那么这个 associatedtype 是什么意思呢？
看个例子就知道了：
第一步：
我们定义两个协议 A,B,协议 B 中用到了协议 A
protocol A {}
protocol B {
func action(_ pA2: A)
}
第二步：
那么我们对协议 A 有两个实现： A1 与 A2.
我们对协议 B 有 B1 的实现.代码如下:
struct A1: A {}
struct A2: A {}
struct B1: B {
func action(_ pA2: A) {
print("我只认对协议A实现的A2")
}
}
这个时候如果我们要使用 B1 的时候,可以这样：
let action = B1()
action.action(A2())
action.action(A1())
///我只认对协议A实现的A2
///我只认对协议A实现的A2
第三步： 条件
这个时候我们在 B1 中对传入协议 A 的类型想要指定的类型实现而传入非指定类型的实现编译器就会报错怎么做？
有人讲这样：
struct B1: B {
func action(_ pA2: A2) {
print("我只认对协议A实现的A2")
}
}
这样子编译器就会报错：Type 'B1' does not conform to protocol 'B'。
这个时候我们的 associatedtype 就可以登场了：
protocol A {}
protocol B {
associatedtype F: A
func action(_ pA2: F)
}
struct A1: A {}
struct A2: A {}
struct B1: B {
func action(_ pA2: A2) {
print("我只认对协议A实现的A2")
}
}
let action = B1()
action.action(A2())
///action.action(A1()) 这个实现就直接报错了：error: OptimizingCollections.playground:16:15: error: cannot convert value of type 'A1' to expected argument type 'A2' action.action(A1())
对 associatedtype 总结就仁者见仁各有各的理解啦！小插曲结束进入正题：↓
2.IteratorProtocol 与迭代器的邂逅
按住 Command 点进去会发现该协议只有一个函数：
associatedtype Element
public mutating func next() -> Self.Element?
以下用 next() 来表示.
可别看它就这么一句；小,但是 能量 很大！！！
迭代器 是一个满足 IteratorProtocol 协议的类型。
普及一个知识：
序列 （Sequence）
具有相同类型的值的一个集合吧。比如简单的： [Int] ... 都是满足 Sequence 协议
的。
那么有了序列就会有需要对值遍历的访问，那么就是靠创建一个 迭代器 来进行对元素的访问。
那么 next() 的作用就是每次调用的时候返回序列的下一个值，直到最后一个返回 nil
这里来开始剖析：
Self.Element
它是一个关联类型用来指定 next() 所产生值的元素类型，比如我们经常见到的 Iterator.Element 就是 IteratorProtocol 中的定义 Element。那么迭代器一般会用在那里呢？
答：自定义序列的扩展类型,比如你想通过字符串 "YinYu" 转换为："["Y", "i", "n", "Y", "u"]" 的扩展类等等等等多的用途！
迭代器在结构上是单向的，顾名思义只能一路 next
对于迭代器类似的操作我们一般都是用
for <#item#> in <#items#> {
<#code#>
}
来完成。 这个一般情况是不推荐使用的。我们要玩就要玩高级的。不然怎么成长呢？是吧！
接下来我们来完成这样一个例子的实现,来为您以后 “抛砖引玉” 一下
首先完成一个 PrefixIterator 实现 IteratorProtocol协议的 struct。
public struct PrefixIterator: IteratorProtocol {
let string: String
var offset: String.Index
init(string: String) {
self.string = string
offset = string.startIndex
}
mutating public func next() -> String? {
guard offset < string.endIndex else { return nil }
let previousSet = offset
offset = string.index(after: offset)
return String(string[previousSet..<offset])
}
}
我们分析上面主要有: mutating,字符串切片(String(string[previousSet..<offset]))
那么有了迭代器，就需要一个装载迭代器的且满足 Sequence 协议的 struct.
因为在 Sequence 中我们发现有这样的一个函数：
associatedtype Iterator : IteratorProtocol
///Returns an iterator over the elements of this sequence
public func makeIterator() -> Self.Iterator
那么这里我们的 PrefixIterator 就相当于 Self.Iterator 类型.
接下来就实现对 Sequence协议的构造。
public struct PrefixSequence: Sequence {
let string: String
public func makeIterator() -> PrefixIterator {
return PrefixIterator(string: string)
}
}
既然实现了 Sequence协议，那么我们就可以得到 Map, filter, forEach, dropFirst... 这些集合类型常用的函数方法。
利用 Map依次返回一个字母。从而达到 "YinYu" 到 "Y", "i", "n", "Y", "u" 的转换
这样一个 String 扩展方法就出来了：
extension String {
func stringToArr() -> [String] {
return PrefixSequence(string: self).map { $0 }
}
}
let strs = "YinYu".stringToArr()
/// ["Y", "i", "n", "Y", "u"]
当然如果你想输出的字面都是大写很简单：
$0.uppercased() 这样就OK啦.
值语义
我们都知道 结构体(Struct) 枚举(enum) 是 值类型。
当创建一个 class(类) 的时候，class 是 引用类型。
对于引用类型的操作我们是要万分小心的,引用类型是具有统一性的一般用 === 判断两个变量是否引用了同一个 object。即：指针相等。
那 == 呢？ 当然是： 结构相等
一般我们通过值类型是否执行 深复制来判断是否具有 值语义.
有深复制就会有 潜复制：
当 Struct 中包含引用类型，这个时候 Struct 进行赋值给其它的变量的时候所发生的复制行为会存在引用类型的内容是不会复制，其引用本身会被复制。这种行为就是 浅复制.
AnyIterator
可以对其它的迭代器进行一个包装,从而迷惑使用者。
这里要说的就是 AnyIterator 在这样的情况下 var 新迭代器 = AnyIterator(旧迭代器) 的时候， 新迭代器是 不具有 值语义的。这种情况下旧迭代器与新迭代器就不是单独的了,新迭代器就不是一个结构体。 新迭代器是以一个类实例。
下面代码见分晓:
var ierator1 = stride(from: 0, to: 10, by: 1).makeIterator()
ierator1.next() /// 0
ierator1.next() /// 1
var ierator2 = ierator1
ierator1.next() /// 2
ierator1.next() /// 3
ierator2.next() /// 2
ierator2.next() /// 3
var ierator3 = AnyIterator(ierator1)
var ierator4 = ierator3
ierator3.next() /// 4
ierator4.next() /// 5
ierator3.next() /// 6
ierator3.next() /// 7
AnySequence
似乎与 Iterator 与 Sequence 一样，也存在着 AnySequence.
AnyIterator 也是对 IteratorProtocol 协议的实现.那么配合 nest() 与对应的 AnySequence，可以得到在不定义任何新类型的情况下创建迭代器序列。
