在软件开发领域，“迭代”的意思是按照顺序反复多次执行一段程序，通常会有明确的终止条件。
    ECMAScript 6规范新增了两个高级特性：迭代器和生成器。
    使用这两个特性，能够更清晰、高效、方便地实现迭代。
    7.1 理解迭代
    在JavaScript中，计数循环就是一种最简单的迭代
    循环是迭代机制的基础，这是因为它可以指定迭代的次数，以及每次迭代要执行什么操作。
    每次循环都会在下一次迭代开始之前完成，而每次迭代的顺序都是事先定义好的。
    迭代会在一个有序集合上进行。（“有序”可以理解为集合中所有项都可以按照既定的顺序被遍历到，特别是开始和结束项有明确的定义。）
    数组是JavaScript中有序集合的最典型例子
    因为数组有已知的长度，且数组每一项都可以通过索引获取，所以整个数组可以通过递增索引来遍历。
    由于如下原因，通过这种循环来执行例程并不理想：
    ❑ 迭代之前需要事先知道如何使用数据结构。数组中的每一项都只能先通过引用取得数组对象，然后再通过[]操作符取得特定索引位置上的项。这种情况并不适用于所有数据结构。
    ❑ 遍历顺序并不是数据结构固有的。通过递增索引来访问数据是特定于数组类型的方式，并不适用于其他具有隐式顺序的数据结构。
    ES5新增了Array.prototype.forEach()方法，向通用迭代需求迈进了一步（但仍然不够理想）：

    1. let collection = ['foo', 'boo', 'baz'];
    2. collection.forEach((item) => console.log(item));
    3. // foo
    4. // boo 
    5. // baz

    这个方法解决了单独记录索引和通过数组对象取得值的问题。不过，没有办法标识迭代何时终止。因此这个方法只适用于数组，而且回调结构也比较笨拙。
    在ECMAScript较早的版本中，执行迭代必须使用循环或其他辅助结构。随着代码量增加，代码会变得越发混乱。很多语言都通过原生语言结构解决了这个问题，开发者无须事先知道如何迭代就能实现迭代操作。这个解决方案就是迭代器模式。JavaScript在ECMAScript 6以后也支持了迭代器模式。
    7.2 迭代器模式
    迭代器模式（特别是在ECMAScript这个语境下）描述了一个方案，即可以把有些结构称为“可迭代对象”（iterable），因为它们实现了正式的Iterable接口，而且可以通过迭代器Iterator消费。
    可迭代对象是一种抽象的说法。基本上，可以把可迭代对象理解成数组或集合这样的集合类型的对象。
    它们包含的元素都是有限的，而且都具有无歧义的遍历顺序：
    image.png
    不过，可迭代对象不一定是集合对象，也可以是仅仅具有类似数组行为的其他数据结构，比如本章开头提到的计数循环。该循环中生成的值是暂时性的，但循环本身是在执行迭代。计数循环和数组都具有可迭代对象的行为。
    注：临时性可迭代对象可以实现为生成器，后面会讨论。
    任何实现Iterable接口的数据结构都可以被实现Iterator接口的结构“消费”（consume）。
    迭代器（iterator）是按需创建的一次性对象。每个迭代器都会关联一个可迭代对象，而迭代器会暴露迭代其关联可迭代对象的API。迭代器无须了解与其关联的可迭代对象的结构，只需要知道如何取得连续的值。这种概念上的分离正是Iterable和Iterator的强大之处。
    7.2.1 可迭代协议
    实现Iterable接口（可迭代协议）要求同时具备两种能力：
    支持迭代的自我识别能力和创建实现Iterator接口的对象的能力。
    在ECMAScript中，这意味着必须暴露一个属性作为“默认迭代器”，而且这个属性必须使用特殊的Symbol.iterator作为键。
    这个默认迭代器属性必须引用一个迭代器工厂函数，调用这个工厂函数必须返回一个新迭代器。
    很多内置类型都实现了Iterable接口：
    ❑ 字符串
    ❑ 数组
    ❑ 映射
    ❑ 集合
    ❑ arguments对象
    ❑ NodeList等DOM集合类型
    检查是否存在默认迭代器属性可以暴露这个工厂函数：
    image.png
    实际写代码过程中，不需要显式调用这个工厂函数来生成迭代器。
    实现可迭代协议的所有类型都会自动兼容接收可迭代对象的任何语言特性。
    接收可迭代对象的原生语言特性包括：
    ❑ for-of循环
    ❑ 数组解构
    ❑ 扩展操作符
    ❑ Array.from()
    ❑ 创建集合
    ❑ 创建映射
    ❑ Promise.all()接收由期约组成的可迭代对象
    ❑ Promise.race()接收由期约组成的可迭代对象
    ❑ yield＊操作符，在生成器中使用
    这些原生语言结构会在后台调用提供的可迭代对象的这个工厂函数，从而创建一个迭代器：

    1. let arr = ['foo', 'boo', 'baz'];
    3. // for-of 循环
    4. for (let el of arr) {
    5.   console.log(el);
    6. }
    7. // foo
    8. // boo
    9. // baz
    11. // 数组解构
    12. let [a,b,c] = arr;
    13. console.log(a,b,c) // foo boo baz
    15. // 扩展操作符
    16. let arr2 = [...arr];
    17. console.log(arr2); // ['foo', 'boo', 'baz']
    19. // Array.from
    20. let arr3 = Array.from(arr);
    21. console.log(arr3); // ['foo', 'boo', 'baz']
    23. // Set构造函数
    24. let set = new Set(arr);
    25. console.log(set); // Set(3) {"foo", "boo", "baz"}
    27. // Map构造函数
    28. let pairs = arr.map((x,i) => [x,i]);
    29. console.log(pairs);  // [["foo",0],["boo",1],['baz',2]]
    30. let map = new Map(pairs);
    31. console.log(map); // Map(3) {"foo" => 0, "boo" => 1, "baz" => 2}

    7.2.2 迭代器协议
    迭代器是一种一次性使用的对象，用于迭代与其关联的可迭代对象。
    迭代器API使用next()方法在可迭代对象中遍历数据。
    每次成功调用next()，都会返回一个IteratorResult对象，其中包含迭代器返回的下一个值。
    若不调用next()，则无法知道迭代器的当前位置。
    next()方法返回的迭代器对象IteratorResult包含两个属性：done和value。
    done是一个布尔值，表示是否还可以再次调用next()取得下一个值；
    value包含可迭代对象的下一个值（done为false），或者undefined（done为true）。
    done: true状态称为“耗尽”。
    可以通过以下简单的数组来演示：

    1. // 可迭代对象
    2. let arr = ['foo', 'bar'];
    3. // 迭代器工厂函数
    4. console.log(arr[Symbol.iterator]); // ƒ values() { [native code] }
    5. // 迭代器
    6. let iter = arr[Symbol.iterator]();
    7. console.log(iter);                 // Array Iterator {}
    8. // 执行迭代
    9. console.log(iter.next());  // {value: "foo", done: false}
    10. console.log(iter.next());  //  {value: "bar", done: false}
    11. console.log(iter.next());  // {value: undefined, done: true}

    这里通过创建迭代器并调用next()方法按顺序迭代了数组，直至不再产生新值。
    迭代器并不知道怎么从可迭代对象中取得下一个值，也不知道可迭代对象有多大。
    只要迭代器到达done: true状态，后续调用next()就一直返回同样的值了：

    1. let arr = ['foo'];
    2. let iter = arr[Symbol.iterator]();
    3. console.log(iter.next());  // {value: "foo", done: false}
    4. console.log(iter.next());  //  {value: undefined, done: true}
    5. console.log(iter.next());  // {value: undefined, done: true}
    6. console.log(iter.next());  // {value: undefined, done: true}

    每个迭代器都表示对可迭代对象的一次性有序遍历。
    不同迭代器的实例相互之间没有联系，只会独立地遍历可迭代对象：
    image.png
    迭代器并不与可迭代对象某个时刻的快照绑定，而仅仅是使用游标来记录遍历可迭代对象的历程。
    如果可迭代对象在迭代期间被修改了，那么迭代器也会反映相应的变化：
    image.png
    注：迭代器维护着一个指向可迭代对象的引用，因此迭代器会阻止垃圾回收程序回收可迭代对象。
    “迭代器”的概念有时候容易模糊，因为它可以指通用的迭代，也可以指接口，还可以指正式的迭代器类型。
    下面的例子比较了一个显式的迭代器实现和一个原生的迭代器实现。
    image.png
    7.2.3 自定义迭代器
    与Iterable接口类似，任何实现Iterator接口的对象都可以作为迭代器使用。
    下面这个例子中的Counter类只能被迭代一定的次数：
    image.png
    这个类实现了Iterator接口，但不理想。这是因为它的每个实例只能被迭代一次：
    image.png
    为了让一个可迭代对象能够创建多个迭代器，必须每创建一个迭代器就对应一个新计数器。
    为此，可以把计数器变量放到闭包里，然后通过闭包返回迭代器：
    image.png
    每个以这种方式创建的迭代器也实现了Iterable接口。
    Symbol.iterator属性引用的工厂函数会返回相同的迭代器：

    1. let arr = ['foo', 'boo', 'bar'];
    2. let iter1 = arr[Symbol.iterator]();
    3. console.log(iter1[Symbol.iterator]); // ƒ [Symbol.iterator]() { [native code] }
    4. let iter2 = iter1[Symbol.iterator]();
    5. console.log(iter1 === iter2);  // true

    因为每个迭代器也实现了Iterable接口，所以它们可以用在任何期待可迭代对象的地方，比如for-of循环：
    image.png
    7.2.4 提前终止迭代器
    可选的return()方法用于指定在迭代器提前关闭时执行的逻辑。
    执行迭代的结构在想让迭代器知道它不想遍历到可迭代对象耗尽时，就可以“关闭”迭代器。
    可能的情况包括：
    ❑ for-of循环通过break、continue、return或throw提前退出；
    ❑ 解构操作并未消费所有值。
    return()方法必须返回一个有效的IteratorResult对象。
    简单情况下，可以只返回{ done: true }。
    因为这个返回值只会用在生成器的上下文中，所以本章后面再讨论这种情况。
    如下面的代码所示，内置语言结构在发现还有更多值可以迭代，但不会消费这些值时，会自动调用return()方法。
    image.png
    image.png
    如果迭代器没有关闭，则还可以继续从上次离开的地方继续迭代。
    比如，数组的迭代器就是不能关闭的：
    image.png
    因为return()方法是可选的，所以并非所有迭代器都是可关闭的。
    要知道某个迭代器是否可关闭，可以测试这个迭代器实例的return属性是不是函数对象。
    不过，仅仅给一个不可关闭的迭代器增加这个方法并不能让它变成可关闭的。
    这是因为调用return()不会强制迭代器进入关闭状态。
    即便如此，return()方法还是会被调用。
    image.png