Swift 懒加载 lazy（集合的懒加载原理）

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的使用规则：

1. 只能修饰结构体和类的成员变量,不能修饰计算属性
2. 只能稀释var,不能是let
3. 不是线程安全的

懒加载序列

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函数