异步遍历的接口

异步遍历器的最大的语法特点,就是调用遍历器的next方法,返回的是一个 Promise 对象。

  1. asyncIterator
  2. .next()
  3. .then(
  4. ({ value, done }) => /* ... */
  5. );

上面代码中,asyncIterator是一个异步遍历器,调用next方法以后,返回一个 Promise 对象。因此,可以使用then方法指定,这个 Promise 对象的状态变为resolve以后的回调函数。回调函数的参数,则是一个具有valuedone两个属性的对象,这个跟同步遍历器是一样的。

我们知道,一个对象的同步遍历器的接口,部署在Symbol.iterator属性上面。同样地,对象的异步遍历器接口,部署在Symbol.asyncIterator属性上面。不管是什么样的对象,只要它的Symbol.asyncIterator属性有值,就表示应该对它进行异步遍历。

下面是一个异步遍历器的例子。

  1. const asyncIterable = createAsyncIterable(['a', 'b']);
  2. const asyncIterator = asyncIterable[Symbol.asyncIterator]();
  3. asyncIterator
  4. .next()
  5. .then(iterResult1 => {
  6. console.log(iterResult1); // { value: 'a', done: false }
  7. return asyncIterator.next();
  8. })
  9. .then(iterResult2 => {
  10. console.log(iterResult2); // { value: 'b', done: false }
  11. return asyncIterator.next();
  12. })
  13. .then(iterResult3 => {
  14. console.log(iterResult3); // { value: undefined, done: true }
  15. });

上面代码中,异步遍历器其实返回了两次值。第一次调用的时候,返回一个 Promise 对象;等到 Promise 对象resolve了,再返回一个表示当前数据成员信息的对象。这就是说,异步遍历器与同步遍历器最终行为是一致的,只是会先返回 Promise 对象,作为中介。

由于异步遍历器的next方法,返回的是一个 Promise 对象。因此,可以把它放在await命令后面。

  1. async function f() {
  2. const asyncIterable = createAsyncIterable(['a', 'b']);
  3. const asyncIterator = asyncIterable[Symbol.asyncIterator]();
  4. console.log(await asyncIterator.next());
  5. // { value: 'a', done: false }
  6. console.log(await asyncIterator.next());
  7. // { value: 'b', done: false }
  8. console.log(await asyncIterator.next());
  9. // { value: undefined, done: true }
  10. }

上面代码中,next方法用await处理以后,就不必使用then方法了。整个流程已经很接近同步处理了。

注意,异步遍历器的next方法是可以连续调用的,不必等到上一步产生的 Promise 对象resolve以后再调用。这种情况下,next方法会累积起来,自动按照每一步的顺序运行下去。下面是一个例子,把所有的next方法放在Promise.all方法里面。

  1. const asyncIterable = createAsyncIterable(['a', 'b']);
  2. const asyncIterator = asyncIterable[Symbol.asyncIterator]();
  3. const [{value: v1}, {value: v2}] = await Promise.all([
  4. asyncIterator.next(), asyncIterator.next()
  5. ]);
  6. console.log(v1, v2); // a b

另一种用法是一次性调用所有的next方法,然后await最后一步操作。

  1. async function runner() {
  2. const writer = openFile('someFile.txt');
  3. writer.next('hello');
  4. writer.next('world');
  5. await writer.return();
  6. }
  7. runner();