ES6异步发电机结果 [英] ES6 asynchronous generator result

问题描述

ES6有发电机返回迭代器：在

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

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

有是返回承诺异步函数的建议：

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

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

所以，如果我将二者结合起来，这样会发生什么：

So what happens if I combine the two, like this:

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

这是什么回报？它是无极＆LT;＆迭代器LT;项目＆GT;＆GT; ？ 的Iterator＆LT;＆承诺LT;项目＆GT;＆GT; ？别的东西吗？我如何使用它？我想应该有一个相应的为循环，是什么将异步迭代它的结果，是这样的：

What does it return? Is it Promise<Iterator<Item>>? Iterator<Promise<Item>>? Something else? How do I consume it? I imagine there should be a corresponding for loop, what will iterate over its result asynchronously, something like:

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

它等待每个项目试图访问下一个前变得可用。

which waits for each item to become available before trying to access the next one.

推荐答案

都不是。它仍然没有批准，但当前实现返回别的东西。克里斯·科瓦尔有写了一个关于异步发电机和引用的贾法尔侯赛因对ES7 AsyncGenerator提案

Promise<Iterator<Item>> or Iterator<Promise<Item>>?

Neither. It's still not approved, but current implementations return something else. Kris Kowal has written an about async generators, and references Jafar Husain's AsyncGenerator proposal for ES7.

让我们来定义某些类型（简体）：

Let's define some types (simplified):

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

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

我们正在寻找的东西，可以这样使用的：

We are looking for something that can be used like this:

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

这是的Iterator＆LT;＆承诺LT; T＆GT;＆GT; 产生同步迭代，其值是承诺。它可以像这样使用：

An Iterator<Promise<T>> produces synchronous iterations, whose values are Promises. It could be used like this:

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

A 无极＆LT;＆迭代器LT; T＆GT;＆GT; 只是一个普通的同步迭代器，开始在未来的：

A Promise<Iterator<T>> is just a regular synchronous iterator, starting in the future:

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

因此​​，不管是的Iterator＆LT;无极＆LT; T＆GT;＆GT; 也不无极＆LT;迭代器＆LT; T＆GT;＆GT; 适宜。目前异步发电机返回 AsyncIterator ！而非：

So neither Iterator<Promise<T>> nor Promise<Iterator<T>> was suitable. Currently async generators return AsyncIterators instead:

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

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

Which perfectly makes sense. Moving to the next element of the iterator is the asynchronous operation, and this can be used exactly like we wanted.

Babeljs.io已经编译异步发电机。 <一href=\"http://babeljs.io/repl/#?experimental=true&evaluate=true&loose=false&spec=false&$c$c=function%20delay(timeout%2C%20val)%20%7B%0A%20%20return%20new%20Promise(resolve%20%3D%3E%20setTimeout(resolve%2C%20timeout%2C%20val))%3B%0A%7D%0A%0Aasync%20function*%20asyncGenerator()%20%7B%0A%20%20for%20(var%20i%20%3D%200%3B%20i%20%3C%205%3B%20i%2B%2B)%20%7B%0A%20%20%20%20await%20delay(500)%3B%0A%20%20%20%20yield%20i%3B%0A%20%20%7D%0A%7D%0A%0Aasync%20function%20forAwait(iter%2C%20fn)%20%7B%0A%20%20for%20(%3B%3B)%20%7B%0A%20%20%20%20let%20iteration%20%3D%20await%20iter.next()%3B%0A%20%20%20%20if%20(iteration.done)%20return%20iteration.value%3B%0A%20%20%20%20await%20fn(iteration.value)%3B%0A%20%20%7D%0A%7D%0A%0A%0Aasync%20function%20main()%20%7B%0A%20%20console.log('Started')%3B%0A%20%20await%20forAwait(asyncGenerator()%2C%20async%20item%20%3D%3E%20%7B%0A%20%20%20%20await%20delay(100)%3B%0A%20%20%20%20console.log(item)%3B%0A%20%20%7D)%3B%0A%20%20console.log('End')%3B%0A%7D%0A%0Amain()%3B\"相对=nofollow> Babeljs.io/repl例如：

Babeljs.io already compiles async generators. Babeljs.io/repl example:

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();

有是一个方便的为的await 环路异步迭代器（在的异步迭代）：

There is a proposal for a convenient for await loop for async iterators (described at Async iteration):

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

更新：

不幸的是，异步等待并没有成为的 的ECMAScript 2016年的。至少等待中提到供将来使用的保留字。

Unfortunately, async-await didn't become a part of ECMAScript 2016. At least await is mentioned a reserved word for future use.

这篇关于ES6异步发电机结果的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！