Sequences ｜ lazy

序列 Sequence

序列协议是集合类型结构中的基础。
序列代表一系列类型相同的元素，你可以对这些元素进行迭代

Sequence协议

Sequence协议是集合类型的基础，Swift中Sequence协议为序列提供了迭代的能力。Sequence 协议只要求实现makeIterator()方法,该方法返回一个迭代器Iterator；

public protocol Sequence {
  // 元素类型
  associatedtype Element 
  // 迭代器类型 == 元素类型
  associatedtype Iterator: IteratorProtocol where Iterator.Element == Element
  //迭代器
  __consuming func makeIterator() -> Iterator
  //...
}

迭代器

序列通过创建一个迭代器来提供对元素的访问。迭代器每次产生一个序列的值，并且当遍历序列时对遍历状态进行管理。在 IteratorProtocol 协议中唯一的一个方法是 next()，这个方法需要在每次被调用时返回序列中的下一个值。当序列被耗尽时，next() 返回 nil

public protocol IteratorProtocol {
  /// The type of element traversed by the iterator.
  associatedtype Element
  mutating func next() -> Element?
}

for循环的背后是编译器创建了一个迭代器，然后不断的调用next(),直到返回nil

// 猜测编译器实现 for
var iter = CustomIterator()
while let x = iter.next(){
        //...
}

例子

1.自定义迭代器类型，遵守IteratorProtocol协议，不需要指明Element类型，编译器会从next的返回类型推断出Element的类型
自定义序列，遵守Sequence协议，同样不需要指明Element类型，编译器会从makeIterator的类型中推断出Element类型。
最后通过for-in 就能不断打印结果了

struct customProtocol:IteratorProtocol{
        //Element 可以省略，编译器会从next的返回类型推断出Element的类型
        //typealias Element = Int
    func next() -> Int? {
        return 1
    }
}
//...
struct customSequence: Sequence{
        //同样，编译器会从makeIterator的类型中推断出Element类型，不需要再次指明
    func makeIterator() -> some IteratorProtocol {
        customProtocol()
    }
}
//...
var customPrint = customSequence()
for i in customPrint{
    print(i) // 由于next返回1，所以这里会无限打印 
}

2.自定义反转一个迭代器

// 先定义一个实现IteratorProtocol 的类型
struct ReverseIterator<T>:IteratorProtocol{
    typealias Element = T;
    
    var arr : [Element];
    var idx = 0;
    
    init(arr:[Element]) {
        self.arr = arr;
        idx = arr.count - 1;
    }
    
    
    mutating func next() -> T? {
        if idx < 0 {
            return nil;
        }else{
            let ele = arr[idx];
            idx = idx - 1;
            return ele;
        }
    }
}


// 再来定义sequence

struct ReverceSequence<T>:Sequence{
    
    var arr:[T];
    
    init(arr:[T]) {
        self.arr = arr;
    }
    
    __consuming func makeIterator() -> ReverseIterator<T> {
        return ReverseIterator(arr: self.arr);
    }
}



//
let array = [2,5,8,10];
for i in ReverceSequence(arr: array){
    // 10 8 5 2
   print(i, separator: "-", terminator: "-");
}

Lazy变量

惰性变量是按需初始化的存储属性，只能在struct或class中使用惰性变量。
例如，创建一个带有惰性变量的Person结构来计算BMI：

struct Person {
    var weight: Double
    var height: Double
    
    lazy var BMIIndex: Double = {
        return weight / pow(height, 2)
    }()
}
///当初始化Person对象时，BMI不会自动计算。而是在第一次引用的时候才计算
var jack = Person(weight: 90, height: 120)
print(jack.BMIIndex)

Lazy Sequences

在Swift标准库中，SequenceType和CollectionType协议都有个叫lazy的计算属性，它能返回一个特殊的LazySequence或LazyCollection。
这些类型只能被用到map、filter、flatMap这样的高阶函数中，而且是以一种惰性的方式。
对于那些不需要完全运行，可能提前退出的情况，使用lazy来进行性能优化效果会非常有效。

func increment(x: Int) -> Int {
    print("访问:\(x)")
    return x + 1
}

let array = Array(0..<10)

print("直接使用map的结果")
let incrementArr = array.map(increment)
print(incrementArr[5])

print("\n使用lazy属性的结果")
let lazyIncrementArr = array.lazy.map(increment)
print(lazyIncrementArr[5])

输出的结果：

直接使用map的结果:
访问:0
访问:1
访问:2
访问:3
访问:4
访问:5
访问:6
访问:7
访问:8
访问:9
6

使用lazy属性的结果:
访问:5
6

• 直接使用map，所有的输出值都被计算出来了！即使只读了第5个元素。
• 使用了lazy，仅调用了第5个元素的计算，其他元素计算并不会被调用。
  使用lazy后，计算量明显降低很多。如果array的体量更大，且increment更复杂，那么节省的计算量就更明显了。

懒加载情景

• 全局的常量/变量都是懒加载的，不需要标记lazy
• 标记为static的存储型的类型属性（常量变量）也是懒加载的，不需要标记lazy；（补充：static可以修饰存储型的和计算型的类型属性，class可以修饰类类型的计算型的类型属性）
• 延迟属性：必须使用lazy var标记；（延迟属性只能使用var修饰，不能使用let修饰）

延迟属性与闭包

• 延迟属性使用lazy var标记声明，其初始值可以使用直接方式创建，也可以使用闭包方式创建；

// 直接方式创建
lazy var person1: Person = Person()

// 闭包方式创建
lazy var person2: Person = {
    let person = Person()
    p.name = "Tom"
    print("Tom...")
    return person
}()

• 闭包不仅仅可以给延迟属性（lazy var）设置初始值，也可以给全局的常/变量、类的属性、对象的属性进行初始值，计算属性本质通过闭包实现的；

let i = {
    return 0
}()

class Person {
    static let a = {
        return 1
    }()

    var b = {
        return 2
    }()
}

• 在布局UI控件的时候，也可以使用闭包方式来完成初始化赋值，这样更便于复用、更简洁；

let leftButton: UIButton = {
    let button = UIButton(frame: buttonSize)
    button.backgroundColor = .black
    button.titleLabel?.text = "left"
    return button
}()

let rightButton: UIButton = {
    let button = UIButton(frame: buttonSize)
    button.backgroundColor = .black
    button.titleLabel?.text = "right"
    return button
}()

• 延迟属性使用闭包方式创建，在闭包中使用self不会产生循环引用；全局的常/变量、类的属性、对象的属性使用闭包方式创建，在闭包中无法使用self；