# 迭代器与生成器

## 迭代器

迭代器模式(特别是在 ECMAScript 这个语境下)描述了一个方案，即可以把有些结构称为“可迭 代对象”(iterable)，因为它们实现了正式的 Iterable 接口，而且可以通过迭代器 Iterator 消费。 可迭代对象是一种抽象的说法。基本上，可以把可迭代对象理解成数组或集合这样的集合类型的对 象。它们包含的元素都是有限的，而且都具有无歧义的遍历顺序:

### 可迭代协议

实现 Iterable 接口(可迭代协议)要求同时具备两种能力:支持迭代的自我识别能力和创建实现 Iterator 接口的对象的能力。在 ECMAScript 中，这意味着必须暴露一个属性作为“默认迭代器”，而 且这个属性必须使用特殊的 Symbol.iterator 作为键。这个默认迭代器属性必须引用一个迭代器工厂 函数，调用这个工厂函数必须返回一个新迭代器。 很多内置类型都实现了 Iterable 接口:

* 字符串
* 数组
* 映射
* 集合
* arguments 对象
* NodeList 等 DOM 集合类型 检查是否存在默认迭代器属性可以暴露这个工厂函数:

```js
let num = 1;
let obj = {};
// 这两种类型没有实现迭代器工厂函数 
console.log(num[Symbol.iterator]); // undefined 
console.log(obj[Symbol.iterator]); // undefined
let str = 'abc';
let arr = ['a', 'b', 'c'];
let map = new Map().set('a', 1).set('b', 2).set('c', 3);
let set = new Set().add('a').add('b').add('c');
let els = document.querySelectorAll('div');
// 这些类型都实现了迭代器工厂函数 
console.log(str[Symbol.iterator]); // f values() { [native code] }
console.log(arr[Symbol.iterator]); // f values() { [native code] }
console.log(map[Symbol.iterator]); // f values() { [native code] } 
console.log(set[Symbol.iterator]); // f values() { [native code] } 
console.log(els[Symbol.iterator]); // f values() { [native code] }
// 调用这个工厂函数会生成一个迭代器
console.log(str[Symbol.iterator]()); // StringIterator {} 
console.log(arr[Symbol.iterator]()); // ArrayIterator {} 
console.log(map[Symbol.iterator]()); // MapIterator {}
console.log(set[Symbol.iterator]()); // SetIterator {} 
console.log(els[Symbol.iterator]()); // ArrayIterator {}


```

实际写代码过程中，不需要显式调用这个工厂函数来生成迭代器。实现可迭代协议的所有类型都会 自动兼容接收可迭代对象的任何语言特性。接收可迭代对象的原生语言特性包括:

* for-of 循环  数组解构
* 扩展操作符
* Array.from()
* 创建集合
* 创建映射
* Promise.all()接收由期约组成的可迭代对象
* Promise.race()接收由期约组成的可迭代对象
* yield\*操作符，在生成器中使用 这些原生语言结构会在后台调用提供的可迭代对象的这个工厂函数，从而创建一个迭代器:

```js

let arr = ['foo', 'bar', 'baz']; 13
// for-of 循环
for (let el of arr) {
  console.log(el);
}
// foo
// bar
// baz
// 数组解构
let [a, b, c] = arr;
console.log(a, b, c); // foo, bar, baz
// 扩展操作符
let arr2 = [...arr];
console.log(arr2); // ['foo', 'bar', 'baz']
// Array.from()
let arr3 = Array.from(arr);
console.log(arr3); // ['foo', 'bar', 'baz']
// Set 构造函数
let set = new Set(arr);
console.log(set); // Set(3) {'foo', 'bar', 'baz'}
// Map 构造函数
let pairs = arr.map((x, i) => [x, i]);
console.log(pairs); // [['foo', 0], ['bar', 1], ['baz', 2]] 
let map = new Map(pairs);
console.log(map); // Map(3) { 'foo'=>0, 'bar'=>1, 'baz'=>2 }
// 如果对象原型链上的父类实现了 Iterable 接口，那这个对象也就实现了这个接口:
class FooArray extends Array { }
let fooArr = new FooArray('foo', 'bar', 'baz');
for (let el of fooArr) {
  console.log(el);
}
// foo
// bar
// baz

```

### 自定义迭代器

```js
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); } 8 // 1
// 2
// 3
for (let i of counter) { console.log(i); }
// 1
// 2
// 3

```

每个以这种方式创建的迭代器也实现了 Iterable 接口。Symbol.iterator 属性引用的工厂函数 会返回相同的迭代器:

```js
let arr = ['foo', 'bar', 'baz'];
let iter1 = arr[Symbol.iterator]();
console.log(iter1[Symbol.iterator]); // f values() { [native code] }
let iter2 = iter1[Symbol.iterator]();
console.log(iter1 === iter2); // true
```

因为每个迭代器也实现了 Iterable 接口，所以它们可以用在任何期待可迭代对象的地方，比如 for-of 循环:

```js
let arr = [3, 1, 4];
let iter = arr[Symbol.iterator]();

for (let item of arr) { console.log(item); } 
// 3
// 1
// 4

for (let item of iter) { console.log(item); } 
// 3
// 1
// 4

```

### 提前终止迭代器

选的 return()方法用于指定在迭代器提前关闭时执行的逻辑。执行迭代的结构在想让迭代器知 道它不想遍历到可迭代对象耗尽时，就可以“关闭”迭代器。可能的情况包括:

* for-of 循环通过 break、continue、return 或 throw 提前退出;
* 解构操作并未消费所有值。 return()方法必须返回一个有效的 IteratorResult 对象。简单情况下，可以只返回{ done: true }。 因为这个返回值只会用在生成器的上下文中，所以本章后面再讨论这种情况。 如下面的代码所示，内置语言结构在发现还有更多值可以迭代，但不会消费这些值时，会自动调用 return()方法。

```js
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
```

如果迭代器没有关闭，则还可以继续从上次离开的地方继续迭代。比如，数组的迭代器就是不能关 闭的:

```js
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 ()方法还是会被调用。

```js
let a = [1, 2, 3, 4, 5];
let iter = a[Symbol.iterator]();
iter.return = function () {
  console.log('Exiting early');
  return { done: true };
};
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


```

## 生成器

生成器是 ECMAScript 6 新增的一个极为灵活的结构，拥有在一个函数块内暂停和恢复代码执行的 能力。这种新能力具有深远的影响，比如，使用生成器可以自定义迭代器和实现协程。

### 生成器基础

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

```js
// 生成器函数声明
function* generatorFn() {}
// 生成器函数表达式
let generatorFn = function*() {}
// 作为对象字面量方法的生成器函数 
let foo = {
  * generatorFn() {}
}
// 作为类实例方法的生成器函数
 class Foo {
  * generatorFn() {}
}
// 作为类静态方法的生成器函数
class Bar {
  static* generatorFn() {}
}
```

**注意 箭头函数不能用来定义生成器函数。** 标识生成器函数的星号不受两侧空格的影响

### 控制并发数

```js
async function* asyncPool(concurrency, iterable, iteratorFn) {
  const executing = new Set();
  async function consume() {
    const [promise, value] = await Promise.race(executing);
    executing.delete(promise);
    return value;
  }
  for (const item of iterable) {
    // Wrap iteratorFn() in an async fn to ensure we get a promise.
    // Then expose such promise, so it's possible to later reference and
    // remove it from the executing pool.
    const promise = (async () => await iteratorFn(item, iterable))().then(
      value => [promise, value]
    );
    executing.add(promise);
    if (executing.size >= concurrency) {
      yield await consume();
    }
  }
  while (executing.size) {
    yield await consume();
  }
}


async function asyncTask(item, iterable) {
  // 模拟异步操作
  await new Promise(resolve => setTimeout(() => {
    console.log(`Task ${item} preparing`);
    resolve()
  }, 1000));
  console.log(`Task ${item} completed`);
  return item
}

async function main() {
  const items = [1, 2, 3, 4, 5];
  const concurrency = 2;
  for await (const result of asyncPool(concurrency, items, asyncTask)) {
    // do something with result
    console.log(`Result: ${result}`);
  }
}

main();
```
