Swift 懒加载 lazy
惰性存储属性是一种直到第一次使用它时才计算其初始值的属性。通过在其声明之前写入lazy修饰符来指示延迟存储属性
lazy var name
OC 中不存在这种机制，都是程序员手写，swift中的懒加载本质是带返回值的函数或者闭包，如下形式：
变量的懒加载
lazy var viewController:UIViewController = {()-> UIViewController in
var vc = UIViewController()
//...
return vc
}()
系统默认可以写成简化版：
lazy var viewController:UIViewController = {
var vc = UIViewController()
//...
return vc
}()
对于变量的声明更简洁：
lazy var viewController = UIViewController()
lazy的使用规则：
- 只能修饰结构体和类的成员变量,不能修饰计算属性
- 只能稀释var,不能是let
- 不是线程安全的
懒加载序列
swift标准库中扩展了Sequence协议，提供lazy属性，LazySequence这个结构体本身什么都没做，作用是前缀效果
extension Sequence {
@inlinable // protocol-only
public var lazy: LazySequence<Self> {
return LazySequence(_base: self)
}
}
标准库为支持延迟编程 (lazy programming) 提供了两个协议：LazySequenceProtocol 和 LazyCollectionProtocol。延迟编程意味着结果只有在真正需要的时候才会计算出来，这是相较于立即编程 (eager programming) 而提出的概念，而后者也是 Swift 默认的编程方式。一个延迟序列 (lazy sequence) 可以在序列的生成和使用之间创建一个隔离：你不必预先创建出整个序列。相反，只有当使用者真正需要序列的下一个元素时，延迟序列才产生这个元素。这种方式不仅仅是一种编程风格，还可以带来性能上的收益。
Sequence协议中filter的实现，其他像map一样的高阶函数实现是类似的，参考源码即可
@inlinable
public __consuming func filter(
_ isIncluded: (Element) throws -> Bool
) rethrows -> [Element] {
return try _filter(isIncluded)
}
@_transparent
public func _filter(
_ isIncluded: (Element) throws -> Bool
) rethrows -> [Element] {
var result = ContiguousArray<Element>()
var iterator = self.makeIterator()
while let element = iterator.next() {
if try isIncluded(element) {
result.append(element)
}
}
return Array(result)
}
以下代码会生成一个新的LazyFilterSequence序列
[1,2,3,4,5,6].lazy.filter{$0%2 == 0}
LazyFilterSequence中的filter的实现
public __consuming func filter(
_ isIncluded: @escaping (Elements.Element) -> Bool
) -> LazyFilterSequence<Self.Elements> {
return LazyFilterSequence(_base: self.elements, isIncluded)
}
再次遍历LazyFilterSequence，会调用迭代器的next()
@inlinable // lazy-performance
public mutating func next() -> Element? {
while let n = _base.next() {
if _predicate(n) {
return n
}
}
return nil
}
所以，带前缀lazy的filter，其实是在新LazyFilterSequence内部保存了一个函数（闭包）_predicate，当需要遍历的时候，会调用next的同时执行这个_predicate函数
