转载

SequenceType 与 GeneratorType

Swift 语言中提供了一种 for .. in 语法的形式，用于遍历集合，比如对于 Array 类型，就可以用 for .. in 来进行遍历。这个语法在很多其他语言中也有提供，省去了我们定义下标的操作。今天我们要了解的就是关于 for .. in 语法的原理，我们可以让我们自己的类也支持这个语法。

何为 for .. in

首先，我们先来了解一下 for .. in 的用法，比如这段代码：

let bookList = ["Swift", "iOS", "Objc"]

for bookName in bookList {

    print(bookName)

}

我们定义了一个数组 bookList ，里面存放了三个字符串。然后我们就可以通过 for … in 循环进行遍历。

数组其实就是 Array 类，我们上面的定义如果写的详细些，应该是这样：

let bookList:Array = ["Swift", "iOS", "Objc"]

也就是说，我们传递给 for … in 语法的，其实是一个 Array 类的实例。那么我们再来看看 Array 类的继承关系：

public struct Array<Element> : CollectionType, MutableCollectionType, _DestructorSafeContainer {
  ...
}

它继承自一个叫做 CollectionType 的协议，然后我们再来看一下 CollectionType 的定义：

public protocol SequenceType {
  ...
}

经过这么一连串的追溯，其实关键就在于这个 SequenceType，一个类如果实现了 SequenceType 协议，那么他就可以使用 for … in 语法进行遍历了。包括我们自己的定义的类。

如何实现 SequenceType 协议

那么，既然我们知道了这个特性，我们就可以让自己定义的类也支持 for .. in 语法。我们先定义一个实体类 Book：

class Book {

    var name:String = ""
    var price:Float = 0.0

    init(name: String, price: Float) {

        self.name = name
        self.price = price

    }

}

Book 类有两个属性，一个是书名，一个是价格，然后还有一个构造方法。

接下来，我们再定义一个类 BookList，它实现了 SequenceType 协议，用来表示 Book 实例的列表。不过再实现之前，我们先看一看 SequenceType 协议都需要实现那些接口：

class BookList: SequenceType {

    ...

    typealias Generator = BookListGenerator

    func generate() -> Generator {

        return BookListGenerator(bookList: self.bookList!)

    }

}

SequenceType 协议中定义了一个 typealias Generator 的属性，这个属性是一个继承自 GeneratorType 的类。

SequenceType 还定义了一个 generate 方法，用于返回我们指定的 GeneratorType 类型。

恩。。怎么又多了个 GeneratorType，好像有点复杂的样子。那么咱们继续看，GeneratorType 是实际生成遍历信息的接口，我们这里的 BookListGenerator 实现了这个协议，那就来看一下代码吧：

class BookListGenerator : GeneratorType {

    typealias Element = Book

    var currentIndex:Int = 0
    var bookList:[Book]?

    init(bookList: [Book]) {

        self.bookList = bookList

    }

    func next() -> Element? {

        guard let list = bookList else { return  nil }

        if currentIndex < list.count {

            let element = list[currentIndex]
            currentIndex++
            return element

        }else {

            return nil

        }

    }

}

代码稍长，请听我给大家一一分解~

首先，GeneratorType 定义了一个属性别名： typealias Element。我们将 Book 类赋值给它，表示我们这个集合中存储的数据类型是 Book 类的实例。
接下来，GeneratorType 还定义了一个 next 方法。用于遍历这个集合，直到 next 方法返回 nil 的时候，遍历结束。

func next() -> Element? {

    guard let list = bookList else { return  nil }

    if currentIndex < list.count {

        let element = list[currentIndex]
        currentIndex++
        return element

    }else {

        return nil

    }

}

next 方法中，先用 guard 关键字进行了一次判断，检查 bookList（也就是实际的数据是否为空），如果为空，就直接返回 nil。宣告遍历结束~
接下来，用了一个叫做 currentIndex 的属性表示当前所遍历到得索引，这个属性的初始值是 0，然后每遍历一个元素，就加 1，直到它的值超出 list.count 的值，就会返回 nil，宣告遍历完成~

这样，我们的 BookListGenerator 就定义完成了（当然，它还声明了一个构造方法，由于实在简单，我们就不多说了~）。再次回到继承自 SequenceType 的 BookList 类中:

class BookList: SequenceType {

    private var bookList:[Book]?

    init() {

        self.bookList = [Book]()

    }

    func addBook(book:Book){

        self.bookList?.append(book)

    }

    typealias Generator = BookListGenerator

    func generate() -> Generator {

        return BookListGenerator(bookList: self.bookList!)

    }

}

这次列出了所有的代码，还是一一分解~

看了上面关于 BookListGenerator 类的定义，相信就不难理解这里的代码了：

typealias Generator = BookListGenerator

func generate() -> Generator {

    return BookListGenerator(bookList: self.bookList!)

}

这两个 SequenceType 接口的方法我们再来观摩下，typealias 就不用多说了，generate 方法会再遍历开始的时候调用一次，每次遍历都会构建一个 Generator 实例，我们这个 BookList 中构建的就是 BookListGenerator，并传入了 self.bookList（这个是实际的数据列表）以供 BookListGenerator 来进行具体的遍历操作。

其他方面嘛，BookList 类还定了一个私有属性，用于实际存放 Book 的列表数据：

private var bookList:[Book]?

还提供了一个构造方法，和一个 addBook 方法，供我们使用，这两个方法比较简单，就不多说啦。

使用我们的 SequenceType 类型

好了，我们的 BookList 就这样完工啦。现在轮到我们检验一下了：

let bookList = BookList()

bookList.addBook(Book(name: "Swift", price: 12.5))
bookList.addBook(Book(name: "iOS" , price: 10.5))
bookList.addBook(Book(name: "Objc", price: 20.0))


for book in bookList {

    print("/(book.name) 价格 ￥/(book.price)")

}