JavaScript 高级程序设计（第 4 版）- 迭代器与生成器

# 理解迭代

循环时迭代机制的基础，可以指定迭代的次数及每次迭代要执行什么操作。每次循环都会在下一次迭代开始之前完成，而每次迭代的顺序都是事先定义好的。迭代会在一个有序集合上进行。

代码语言：javascript复制

let collection = ['foo', 'bar', 'baz'];

for (let i = 0; i < collection.length;   i) {
  console.log(collection[i]);
}

collection.forEach((item) => console.log(item));

数组循环执行的限制
- 迭代之前需要事先知道如何使用数据结构（数组中的每一项都只能先通过引用取得数组对象，然后再通过[]操作符取得特定索引位置上的项）
- 遍历顺序并不是数据结构固有的（通过递增索引来访问数据是特定于数组类型的方式）
forEach的缺陷
- 解决了单独记录索引和通过数组对象取值的问题，当没办法标识迭代何时终止，只适用于数组
- 回调结构笨拙

# 迭代器模式

迭代器模式，即把有些结构称为“可迭代对象”，它们实现了正式的Iterable接口，而且可以通过迭代器Iterator消费。可以把可迭代对象理解成数组或集合这样的集合类型的对象，其包含的元素是有限的，而且都具有无歧义的遍历顺序。（可迭代对象不一定是集合对象，可以是具有类似数组行为的其他数据结构）
任何实现Iterable接口的数据结构都可以被实现Iterator接口的结构消费。迭代器是按需创建的一次性对象。每个迭代器都会关联一个可迭代对象，而迭代器会暴露迭代其关联可迭代对象的API。迭代器无须了解与其关联的可迭代对象的结构，只需要知道如何取得连续的值。

# 可迭代协议

实现Iterable接口(可迭代协议)需要具备
- 支持迭代的自我识别能力
- 创建实现Iterator接口对象的能力
在ECMAScript中，需暴露使用Symbol.iterator作为键的属性作为默认迭代器
- 默认迭代器属性必须引用一个迭代器工厂函数
- 调用上述工厂函数必须返回一个新迭代器
实现Iterator接口的内置类型
- String
- Array
- Map
- Set
- arguments对象
- NodeList等DOM集合类型
接收可迭代对象的原生语言特性
- for-of循环
- 数组解构
- 扩展符操作
- Array.from()
- 创建集合
- 创建映射
- Promise.all()接收由Promise组成的可迭代对象
- Promise.race()接收由Promise组成的可迭代对象
- yield*操作符，在生成器中使用
原生语言结构会在后台调用提供的可迭代对象的这个工厂函数，从而创建一个迭代器
如果对象原型链上的父类实现了Iterable接口，那么这个对象也就实现了这个接口

# 迭代器协议

迭代器是一种一次性使用的对象，用于迭代与其关联的可迭代对象
迭代器API使用next()方法在可迭代对象中遍历数据
- 每次成功调用next(),都会返回一个IteratorResult对象，其中包含迭代器返回的下一个值
- 若不调用next()，则无法知道迭代器的当前位置
- next()返回的迭代器对象IteratorResult包含属性：done和value
  - done为布尔值，表是否可以再次调用next()获取下一个值
  - value包含可迭代对象的下一个值或undefined
迭代器并不知道怎么从可迭代对象中取得下一个值，也不知道可迭代对象有多大
每个迭代器都表示对可迭代对象的一次性有序遍历。不同迭代器的实例相互之间没有联系，只会独立地遍历可迭代对象
迭代器并不与可迭代对象某个时刻的快照绑定，而仅仅是使用游标来记录遍历可迭代对象的历程。
如果可迭代对象在迭代期间被修改了，那么迭代器也会反映相应的变化

代码语言：javascript复制

// 这个类实现了可迭代接口Iterable
// 调用默认的迭代器工厂函数会返回
// 一个实现迭代器接口(Iterator)的迭代对象
class Foo {
  [Symbol.iterator]() {
    return {
      next() {
        return { done: false, value: 'foo' };
      }
    }
  }
}
let f = new Foo();
// 输出实现了迭代器接口的对象
console.log(f[Symbol.iterator]()); // { next: f(){} }

// Array类型实现了可迭代接口Iterable
// 调用Array类型的默认迭代器工厂函数会创建一个ArrayIterator的实例
let a = new Array();

console.log(a[Symbol.iterator]()); // Array Iterator{}

# 自定义迭代器

与Iterable接口类似，任何实现Iterator接口的对象都可以作为迭代器使用

代码语言：javascript复制

class Counter {
  constructor(limit) {
    this.limit = limit;
  }
  [Symbol.iterator]() {
    let count = 1,
        limit = this.limit;
    return {
      next() {
        if (count < limit) {
          return { done:false, value: count   };
        } else {
          return { done: true, value: undefined };
        }
      }
    }
  }
}
let counter = new Counter(3);
for (let i of counter) { console.log(i); }
// 1
// 2
// 3

# 提前终止迭代器

可选的return()方法用于指定在迭代器提前关闭时执行的逻辑
执行迭代的结构在想让迭代器知道它不想遍历到可迭代对象耗尽时，可以关闭迭代器
- for-of循环通过break、continue、return或throw提前退出
- 解构操作并未消费所有值
return()方法必须返回一个有效的IteratorResult对象
- 简单情况下，可以只返回 { done: true }
- 该返回值只会用在生成器的上下文中
内置语言结构在发现还有更多值可迭代，但不会消费这些值时，会自动调用return()

代码语言：javascript复制

class Counter {
  constructor(limit) {
    this.limit = limit;
  }
  [Symbol.iterator]() {
    let count = 1,
        limit = this.limit;
    return {
      next() {
        if (count <= limit) {
          return { done: false, value: count   };
        } else {
          return { done: true };
        }
      },
      return() {
        console.log("Exiting early");
        return { done: true };
      }
    };
  }
}
let counter1 = new Counter(5);

for (let i of counter1) {
  if (i > 2) {
    break;
  }
  console.log(i);
}
// 1
// 2
// Exiting early

let counter2 = new Counter(5);

try {
  for (let i of counter2) {
    if (i > 2) {
      throw 'err';
    }
    console.log(i);
  }
} catch (e) {}
// 1
// 2
// Exiting early

let counter3 = new Counter(5);
let [a, b] = counter3;
// Exiting early

如果迭代器没有关闭，则还可以继续从上次离开的地方继续迭代

代码语言：javascript复制

let a = [1,2,3,4,5];
let iter = a[Symbol.iterator]();

for (let i of iter) {
  console.log(i);
  if (i > 2) {
    break;
  }
}
// 1
// 2
// 3

for (let i of iter) {
  console.log(i);
}
// 4
// 5

return()方法是可选的，所以并非所有迭代器都是可关闭的
- 要知道某个迭代器是否可关闭，可测试这个迭代器实例的return属性是不是函数
- 仅仅给一个不可关闭的迭代器增加return方法不能让他变成可关闭的，因为调用return()不会强制迭代器进入关闭状态

# 生成器

ES6新增结构，拥有在一个函数块内暂停和恢复代码执行能力。该能力有深远影响，如使用生成器可以自定义迭代器和实现协程。

# 生成器基础

生成器的形式是一个函数，函数名称前面加一个*表示其是一个生成器。只要是可以定义函数的地方，就可以定义生成器。

代码语言：javascript复制

// 生成器函数声明
function* generatorFn() {}

// 生成器函数表达式
let generatorFn = function* () {}

// 作为对象字面量方法的生成器函数
let foo = {
  * generatorFn() {}
}

// 作为类实例方法的生成器函数
class Foo {
  * generatorFn() {}
}

// 作为类静态方法的生成器函数
class Bar {
  static * generatorFn() {}
}

标识生成器函数的星号*不受两侧空格的影响

调用生成器函数会产生一个生成器对象

生成器对象一开始处于暂停执行(suspended)的状态
与迭代器相似，生成器对象也实现了Iterator接口，具有next()方法。调用该方法会让生成器开始或恢复执行

代码语言：javascript复制

function* generatorFn() {}
const g = generatorFn();
console.log(g); // generatorFn {<suspended>}
console.log(g.next); // f next() {[native code]}

复制

javascript 程序设计对象函数接口

0 人点赞