ES6异步发生器结果

时间:2016-01-09 12:57:31

标签: javascript async-await ecmascript-6 generator ecmascript-next

ES6有generators that return iterators

function* range(n) {
    for (let i = 0; i < n; ++i) {
        yield i;
    }
}

for (let x of range(10)) {
    console.log(x);
}

有一个返回Promises的异步函数的提议:

async function f(x) {
    let y = await g(x);
    return y * y;
}

f(2).then(y => {
    console.log(y);
});

如果我将两者结合起来会发生什么,例如:

async function* ag(n) {
    for (let i = 0; i < n; ++i) {
         yield i;
    }
}

它返回什么?是Promise<Iterator<Item>>吗? Iterator<Promise<Item>>?别的什么?我该如何食用?我想应该有一个相应的for循环,它会异步迭代它的结果,如:

for (await let x of ag(10)) {
    console.log(x);
}

等待每个项目在尝试访问下一个项目之前可用。

2 个答案:

答案 0 :(得分:5)

Promise<Iterator<Item>>Iterator<Promise<Item>>

都不是。它仍然没有被批准,但是当前的实现还会返回其他内容。 Kris Kowal有written an about async generators,参考Jafar Husain's AsyncGenerator proposal for ES7编辑:我们有tc39 proposalbabel support

让我们定义一些类型(简化):

interface Iterator<T> {
  Iteration<T> next();
}

type Iteration<T> = { done: boolean, value: T }

我们正在寻找可以像这样使用的东西:

for (;;) {
    var iteration = await async_iterator.next();
    if (iteration.done) {
        return iteration.value;
    } else {
        console.log(iteration.value);
    }
}

Iterator<Promise<T>>生成同步迭代,其值为Promises。它可以像这样使用:

for (;;) {
    var iteration = iterator_promise.next();
    if (iteration.done) {
        return await iteration.value;
    } else {
        console.log(await iteration.value);
    }
}

Promise<Iterator<T>>只是一个常规的同步迭代器,从未来开始:

var iterator = await promise_iterator;
for (;;) {
    var iteration = iterator.next();
    if (iteration.done) {
        return iteration.value;
    } else {
        console.log(iteration.value);
    }
}

因此,Iterator<Promise<T>>Promise<Iterator<T>>都不合适。目前,异步生成器返回AsyncIterator

interface AsyncIterator<T> {
  Promise<Iteration<T>> next();
}

这完全有道理。移动到迭代器的下一个元素是异步操作,这可以像我们想的那样使用。

如何使用异步生成器?

Babeljs.io已经编译了异步生成器。 Babeljs.io/repl example

编辑:babeljs.io上没有预设编译异步生成器,因为babel 6,babel-plugin-transform-regenerator支持{asyncGenerators:true}选项。

编辑:请参阅transform-async-generator-functions babel 6插件。

function delay(timeout, val) {
  return new Promise(resolve => setTimeout(resolve, timeout, val));
}

async function* asyncGenerator() {
  for (var i = 0; i < 5; i++) {
    await delay(500);
    yield i;
  }
}

async function forAwait(iter, fn) {
  for (;;) {
    let iteration = await iter.next();
    if (iteration.done) return iteration.value;
    await fn(iteration.value);
  }
}


async function main() {
  console.log('Started');
  await forAwait(asyncGenerator(), async item => {
    await delay(100);
    console.log(item);
  });
  console.log('End');
}

main();

有一个方便的for await循环的提议,用于异步迭代器(在Async iteration中描述):

for await (let line of readLines(filePath)) {
    print(line);
}

<强>更新

不幸的是,async-await并未成为ECMAScript 2016的一部分。至少await被提及为将来使用的保留字。

<强>更新

相关提案:

答案 1 :(得分:0)

想一想: 迭代器函数没有返回值,因此将它们设置为异步毫无意义。 那么这两种方法之间存在这种概念上的差距。 - 迭代器是基于拉取的:你调用迭代器并调用新值的计算 - Promise是基于推送的:Promise将结果推向了它的倾听者。 (曾经或从未)

虽然在某些情况下会创建一个Iterator<Pomise<Item>>

function* f(g){
    for(...){
        let y = await g();
        yield y;
    }
}

我无法想到将Iterator包装成Promise是有意义的。因为从它的定义中实例化Iterator没有任何异步。