集合类型协议 序列

序列: sequence

满足sequence协议只需提供一个返回迭代器(iterator)：的makeIterator方法。 集合<-Sequence<-Iterator

迭代器：Iterator

里面只有一个方法next( )

public protocol IteratorProtocol {
    ///关联类型 Element 指定了迭代器产生的值的类型 
    ///如 subViews的迭代原生类型就是View 可以不用写，编译器根据next()的返回值自动判断。
    associatedtype Element
    
    ///你只需要在每次调用的时候返回下一个值，结束时返回nil
    public mutating func next() -> Self.Element?
}

next( )方法是用 mutating 关键字修饰。 几乎所有的迭代器都要求是可变状态，这样才可以管理在序列中的当前位置

注：迭代器是单向结构，只能按照增加的方向前进，不能倒退或者重置。

准守序列(sequence)协议自定义迭代器和自定义集合

第一步: 创建一个迭代器(Iterator)

struct PrefixStrIterator:IteratorProtocol {
    var string: String
    var offset: String.Index
    init(string:String) {
        self.string = string
        offset = string.startIndex
    }
    ///写协议方法
    mutating func next() -> String? {
        guard offset < string.endIndex else { return nil}
        offset = string.index(after: offset)
        return String(string[string.startIndex..<offset])
    }
}

第二步: 创建一个使用这个迭代器的序列(sequence)

///step2.创建一个属于你的集合
struct PrefixSequence: Sequence {
    var string: String
    
    ///协议方法：返回一个迭代器
    func makeIterator() -> PrefixStrIterator {
        return PrefixStrIterator(string: string)
    }
}

第三步: run

        ///myfirstSquence 我的第一个集合
            print(prefixStr)
        }

• 迭代器和值语义

值语义 struct,应该还有其他类型。待补充。 赋值时不存在引用，复制了一份过去了 引用语义 class 赋值时存在引用 注：但AnyIterator这个是引用对象。

• 基于函数的迭代器和序列

AnyIterator还有一个初始化方法就是直接接受next()函数来当做参数。然后通过引用语义的特性,可以不创建新的类型就写一个斐波那契迭代器

/// 通过引用语义的特性写斐波那契
func fibsIterator() -> AnyIterator<Any> {
    var startNum = (0, 1)
    return AnyIterator{
        let nextNum = startNum.0
            startNum = (startNum.1 , startNum.0 + startNum.1)
        return nextNum
    }
}

无限序列

序列可以是无限的，而集合是有限的。

不稳定序列

Sequence文档明确指出序列并不保证能被多次遍历。 原因是Sequence协议并不关心里面的序列元素会不会销毁。 这就是为什么在集合类型中.first 在序列中并不存在。

序列sequence和迭代器Iterator的关系

迭代器Iterator可以看成即将返回的元素组成的不稳定序列sequence

子序列

Sequence还有一个关联类型 SubSequence

在返回原序列Sequence的切片slice操作中，SubSequence会被当做返回值的子类。

SubSequence 有一些常用方法

prefix 
suffix
dropFirst
dropLast
split

• for 循环 Swift实现了两个范围操作符，闭合操作符和半开操作符。 第一个包括范围中的所有值。 例如，以下包括从0到4的所有整数： 0 ... 4 半开操作符不包括最后一个元素。 以下产生相同的0到4结果： 0 .. <5

• 值类型、引用类型

struct Tutorial {
  var difficulty: Int = 1
}
 
var tutorial1 = Tutorial()
var tutorial2 = tutorial1
tutorial2.difficulty = 2

for _ in 0...4 {
}

tutorial1.difficulty是1，而tutorial2.difficulty是2。 Swift中的结构是值类型，它们通过值而不是引用来复制

如果Tutorial是一个类，tutorial1.difficulty和tutorial2.difficulty将是2.在Swift中的类是引用类型。 对tutorial1的属性的任何更改都将反映到tutorial2中，反之亦然。

• var与let

var view1 = UIView()
view1.alpha = 0.5
 
let view2 = UIView()
view2.alpha = 0.5

view1是一个变量，可以重新分配给一个新的UIView实例。 通过let声明只能赋值一次，所以下面的代码不编译：

view2 = view1 // Error: view2 is immutable

但是，UIView是一个具有引用语义的类，所以你可以改变view2的属性（这意味着最后一行将编译）：

let view2 = UIView() view2.alpha = 0.5 // Yes!

• 闭包简化步骤

let sortedAnimals = animals.sort { (one: String, two: String) -> Bool in
  return one < two
}

第一个简化与参数有关。类型推理系统可以计算闭包中的参数的类型，所以你可以摆脱它们：

let sortedAnimals = animals.sort { (one, two) -> Bool in return one < two }

返回类型也可以推断，所以放弃它：

let sortedAnimals = animals.sort { (one, two) in return one < two }

$ i表示法可以替换参数名称：

let sortedAnimals = animals.sort { return $0 < $1 }

在单语句闭包中，可以省略return关键字。最后一条语句的返回值成为闭包的返回值：

let sortedAnimals = animals.sort { $0 < $1 }

对于字符串，有一个比较函数定义如下：

func <(lhs: String, rhs: String) -> Bool

这个整洁的小函数使你的代码像下面这样容易：

let sortedAnimals = animals.sort(<)

请注意，此渐进的每个步骤都会编译并输出相同的结果，并且创建了一个字符闭包！