Das Erscheinen von Generatorfunktionen in JavaScript geht auf die Einführung von async/await zurück, was bedeutet, dass beim Erstellen eines asynchronen Generators (der immer Promise zurückgibt und mit await generiert werden kann) Code> Gerät), führt es auch viele Dinge ein, die Aufmerksamkeit erfordern. <br><code>Promise 且可以 await 的生成器）的同时，还引入了许多需要注意的事项。
今天，我们将研究异步生成器及其近亲——异步迭代。
注意：尽管这些概念应该适用于所有遵循现代规范的 javascript，但本文中的所有代码都是针对 Node.js 10、12和 14 版开发和测试的。
视频教程推荐：node js教程
异步生成器函数
看一下这个小程序：
// File: main.js
const createGenerator = function*(){
yield 'a'
yield 'b'
yield 'c'
}
const main = () => {
const generator = createGenerator()
for (const item of generator) {
console.log(item)
}
}
main()Nach dem Login kopieren
这段代码定义了一个生成器函数，用该函数创建了一个生成器对象，然后用 for ... of 循环遍历该生成器对象。相当标准的东西——尽管你绝不会在实际工作中用生成器来处理如此琐碎的事情。如果你不熟悉生成器和 for ... of 循环，请看《Javascript 生成器》 和 《ES6 的循环和可迭代对象的》 这两篇文章。在使用异步生成器之前，你需要对生成器和 for ... of 循环有扎实的了解。
假设我们要在生成器函数中使用 await，只要需要用 async 关键字声明函数，Node.js 就支持这个功能。如果你不熟悉异步函数，那么请看 《在现代 JavaScript 中编写异步任务》一文。
下面修改程序并在生成器中使用 await。
// File: main.js
const createGenerator = async function*(){
yield await new Promise((r) => r('a'))
yield 'b'
yield 'c'
}
const main = () => {
const generator = createGenerator()
for (const item of generator) {
console.log(item)
}
}
main()Nach dem Login kopieren
同样在实际工作中，你也不会这样做——你可能会 await 来自第三方 API 或库的函数。为了能让大家轻松掌握，我们的例子尽量保持简单。
如果尝试运行上述程序，则会遇到问题：
$ node main.js
/Users/alanstorm/Desktop/main.js:9
for (const item of generator) {
^
TypeError: generator is not iterableNach dem Login kopieren
JavaScript 告诉我们这个生成器是“不可迭代的”。乍一看，似乎使生成器函数异步也意味着它生成的生成器是不可迭代的。这有点令人困惑，因为生成器的目的是生成“以编程方式”可迭代的对象。
接下来搞清楚到底发生了什么。
检查生成器
如果你看了 Javascript 生成器这篇文章 ，那么就应该知道，如果对象定义了 Symbol.iterator 方法，并且该方法返回，则它在 javascript 中是一个实现了迭代器协议的可迭代对象。当对象具有 next 方法时，该对象将实现迭代器协议，并且该 next 方法返回带有 value 属性，done 属性之一或同时带有 value 和 done 属性的对象。
如果用下面这段代码比较异步生成器函数与常规生成器函数返回的生成器对象：
// File: test-program.js
const createGenerator = function*(){
yield 'a'
yield 'b'
yield 'c'
}
const createAsyncGenerator = async function*(){
yield await new Promise((r) => r('a'))
yield 'b'
yield 'c'
}
const main = () => {
const generator = createGenerator()
const asyncGenerator = createAsyncGenerator()
console.log('generator:',generator[Symbol.iterator])
console.log('asyncGenerator',asyncGenerator[Symbol.iterator])
}
main()Nach dem Login kopieren
则会看到，前者没有 Symbol.iterator 方法，而后者有。
$ node test-program.js
generator: [Function: [Symbol.iterator]]
asyncGenerator undefined
Nach dem Login kopieren
这两个生成器对象都有一个 next 方法。如果修改测试代码来调用这个 next 方法：
// File: test-program.js
/* ... */
const main = () => {
const generator = createGenerator()
const asyncGenerator = createAsyncGenerator()
console.log('generator:',generator.next())
console.log('asyncGenerator',asyncGenerator.next())
}
main()Nach dem Login kopieren
则会看到另一个问题：
$ node test-program.js
generator: { value: 'a', done: false }
asyncGenerator Promise { <pending> }Nach dem Login kopieren
为了使对象可迭代，next 方法需要返回带有 value 和 done 属性的对象。一个 async 函数将总是返回一个 Promise 对象。这个特性会带到用异步函数创建的生成器上——这些异步生成器始终会 yield 一个 Promise 对象。
这种行为使得 async 函数的生成器无法实现 javascript 迭代协议。
异步迭代
幸运的是有办法解决这个矛盾。如果看一看 async 生成器返回的构造函数或类
// File: test-program.js
/* ... */
const main = () => {
const generator = createGenerator()
const asyncGenerator = createAsyncGenerator()
console.log('asyncGenerator',asyncGenerator)
}Nach dem Login kopieren
可以看到它是一个对象，其类型或类或构造函数是 AsyncGenerator 而不是 Generator
Heute werfen wir einen Blick auf asynchrone Generatoren und ihre enge Verwandte, die asynchrone Iteration.
Hinweis
: Diese Konzepte
sollten für jedes Javascript gelten, das modernen Spezifikationen folgt, der gesamte Code in diesem Artikel wurde jedoch für die Node.js-Versionen 10, 12 und 14 entwickelt und getestet. 🎜
🎜Empfohlenes Video-Tutorial: node js Tutorial 🎜
Asynchrone Generatorfunktion
🎜Sehen Sie sich dieses kleine Programm an: 🎜
asyncGenerator Object [AsyncGenerator] {}Nach dem Login kopieren
🎜Dieser Code definiert eine Generatorfunktion, die zum Erstellen eines Generatorobjekts verwendet wird. und verwenden Sie dann
for ... of, um das Generatorobjekt zu durchlaufen. Ziemlich normales Zeug – obwohl man für etwas so Triviales wie dieses eigentlich nie einen Generator verwenden würde. Wenn Sie mit Generatoren und
for ... of-Schleifen nicht vertraut sind, lesen Sie bitte „
Javascript Generator" und "
ES6-Schleifen und iterierbare Objekte“ Diese beiden Artikel. Bevor Sie asynchrone Generatoren verwenden, müssen Sie über solide Kenntnisse von Generatoren und
for ... of-Schleifen verfügen. 🎜🎜Angenommen, wir möchten
await in der Generatorfunktion verwenden. Node.js unterstützt diese Funktion, solange die Funktion mit dem Schlüsselwort
async deklariert werden muss. Wenn Sie mit asynchronen Funktionen nicht vertraut sind, lesen Sie bitte
Asynchrones Schreiben in einer modernen JavaScript-Mission< /a>" Artikel. 🎜🎜Ändern Sie das Programm unten und verwenden Sie await im Generator. 🎜// File: main.js
const createAsyncGenerator = async function*(){
yield await new Promise((r) => r('a'))
yield 'b'
yield 'c'
}
const main = async () => {
const asyncGenerator = createAsyncGenerator()
let result = {done:false}
while(!result.done) {
result = await asyncGenerator.next()
if(result.done) { continue; }
console.log(result.value)
}
}
main()Nach dem Login kopieren
Nach dem Login kopieren
warten. Damit es für jeden leicht verständlich ist, sind unsere Beispiele so einfach wie möglich gehalten. 🎜🎜Wenn Sie versuchen, das obige Programm auszuführen, werden Sie auf ein Problem stoßen: 🎜const createAsyncGenerator = async function*(){
yield await new Promise((r) => r('a'))
yield 'b'
yield 'c'
}
const main = async () => {
const asyncGenerator = createAsyncGenerator()
for await(const item of asyncGenerator) {
console.log(item)
}
}
main()Nach dem Login kopieren
Nach dem Login kopieren
Check Generator
🎜Wenn Sie Javascript Generator-Artikel, dann sollten Sie wissen, dass, wenn das Objekt die
Symbol.iterator-Methode definiert und die Methode zurückgibt, es sich um eine Implementierung in Javascript handelt von
Iterator-Protokoll. Wenn ein Objekt über eine next-Methode verfügt, implementiert das Objekt das Iteratorprotokoll und die next-Methode gibt done mit einem <code>value-Attribut zurück. Eines der -Attribute oder ein Objekt mit den Attributen value und done. 🎜🎜Wenn Sie den folgenden Code verwenden, um die von der asynchronen Generatorfunktion und der regulären Generatorfunktion zurückgegebenen Generatorobjekte zu vergleichen: 🎜$ node main.js
a
b
c
Nach dem Login kopieren
Nach dem Login kopieren
Symbol.iterator hat Methode, während letztere haben. 🎜for await(const item of [1,2,3]) {
console.log(item)
}Nach dem Login kopieren
Nach dem Login kopieren
next-Methode. Wenn Sie den Testcode ändern, um diese next-Methode aufzurufen: 🎜let count = 0
const getCount = () => {
count++
return `${count}. `
}
const createAsyncGenerator = async function*() {
console.log(getCount() + 'entering createAsyncGenerator')
console.log(getCount() + 'about to yield a')
yield await new Promise((r)=>r('a'))
console.log(getCount() + 're-entering createAsyncGenerator')
console.log(getCount() + 'about to yield b')
yield 'b'
console.log(getCount() + 're-entering createAsyncGenerator')
console.log(getCount() + 'about to yield c')
yield 'c'
console.log(getCount() + 're-entering createAsyncGenerator')
console.log(getCount() + 'exiting createAsyncGenerator')
}
const main = async () => {
console.log(getCount() + 'entering main')
const asyncGenerator = createAsyncGenerator()
console.log(getCount() + 'starting for await loop')
for await(const item of asyncGenerator) {
console.log(getCount() + 'entering for await loop')
console.log(getCount() + item)
console.log(getCount() + 'exiting for await loop')
}
console.log(getCount() + 'done with for await loop')
console.log(getCount() + 'leaving main')
}
console.log(getCount() + 'before calling main')
main()
console.log(getCount() + 'after calling main')Nach dem Login kopieren
Nach dem Login kopieren
next-Methode verwendet werden muss mit einem Objekt mit den Eigenschaften value und done zurückgegeben werden. Eine async-Funktion gibt immer ein Promise-Objekt zurück. Diese Funktion erstreckt sich auf Generatoren, die mit asynchronen Funktionen erstellt wurden – diese asynchronen Generatoren ergeben immer ein Promise-Objekt. 🎜🎜Dieses Verhalten macht es Generatoren von async-Funktionen unmöglich, das Javascript-Iterationsprotokoll zu implementieren. 🎜Asynchrone Iteration
🎜Glücklicherweise gibt es eine Möglichkeit, diesen Widerspruch aufzulösen. Wenn Sie sich den Konstruktor oder die Klasse ansehen, die vom async-Generator 🎜rrreee🎜 zurückgegeben werden, können Sie sehen, dass es sich um ein Objekt handelt, dessen Typ oder Klasse oder Konstruktor AsyncGenerator und nicht < code ist >Generator: 🎜rrreee🎜Obwohl das Objekt möglicherweise nicht iterierbar ist, ist es 🎜asynchron iterierbar🎜. 🎜要想使对象能够异步迭代，它必须实现一个 Symbol.asyncIterator 方法。这个方法必须返回一个对象，该对象实现了异步版本的迭代器协议。也就是说，对象必须具有返回 Promise 的 next 方法，并且这个 promise 必须最终解析为带有 done 和 value 属性的对象。
一个 AsyncGenerator 对象满足所有这些条件。
这就留下了一个问题——我们怎样才能遍历一个不可迭代但可以异步迭代的对象？
for await … of 循环
只用生成器的 next 方法就可以手动迭代异步可迭代对象。 （注意，这里的 main 函数现在是 async main ——这样能够使我们在函数内部使用 await）
// File: main.js
const createAsyncGenerator = async function*(){
yield await new Promise((r) => r('a'))
yield 'b'
yield 'c'
}
const main = async () => {
const asyncGenerator = createAsyncGenerator()
let result = {done:false}
while(!result.done) {
result = await asyncGenerator.next()
if(result.done) { continue; }
console.log(result.value)
}
}
main()Nach dem Login kopieren
Nach dem Login kopieren
但是，这不是最直接的循环机制。我既不喜欢 while 的循环条件，也不想手动检查 result.done。另外， result.done 变量必须同时存在于内部和外部块的作用域内。
幸运的是大多数（也许是所有？）支持异步迭代器的 javascript 实现也都支持特殊的 for await ... of 循环语法。例如：
const createAsyncGenerator = async function*(){
yield await new Promise((r) => r('a'))
yield 'b'
yield 'c'
}
const main = async () => {
const asyncGenerator = createAsyncGenerator()
for await(const item of asyncGenerator) {
console.log(item)
}
}
main()Nach dem Login kopieren
Nach dem Login kopieren
如果运行上述代码，则会看到异步生成器与可迭代对象已被成功循环，并且在循环体中得到了 Promise 的完全解析值。
$ node main.js
a
b
c
Nach dem Login kopieren
Nach dem Login kopieren
这个 for await ... of 循环更喜欢实现了异步迭代器协议的对象。但是你可以用它遍历任何一种可迭代对象。
for await(const item of [1,2,3]) {
console.log(item)
}Nach dem Login kopieren
Nach dem Login kopieren
当你使用 for await 时，Node.js 将会首先在对象上寻找 Symbol.asyncIterator 方法。如果找不到，它将回退到使用 Symbol.iterator 的方法。
非线性代码执行
与 await 一样，for await 循环会将非线性代码执行引入程序中。也就是说，你的代码将会以和编写的代码不同的顺序运行。
当你的程序第一次遇到 for await 循环时，它将在你的对象上调用 next。
该对象将 yield 一个 promise，然后代码的执行将会离开你的 async 函数，并且你的程序将继续在该函数之外执行。
一旦你的 promise 得到解决，代码执行将会使用这个值返回到循环体。
当循环结束并进行下一个行程时，Node.js 将在对象上调用 next。该调用会产生另一个 promise，代码执行将会再次离开你的函数。重复这种模式，直到 Promise 解析为 done 为 true 的对象，然后在 for await 循环之后继续执行代码。
下面的例子可以说明一点：
let count = 0
const getCount = () => {
count++
return `${count}. `
}
const createAsyncGenerator = async function*() {
console.log(getCount() + 'entering createAsyncGenerator')
console.log(getCount() + 'about to yield a')
yield await new Promise((r)=>r('a'))
console.log(getCount() + 're-entering createAsyncGenerator')
console.log(getCount() + 'about to yield b')
yield 'b'
console.log(getCount() + 're-entering createAsyncGenerator')
console.log(getCount() + 'about to yield c')
yield 'c'
console.log(getCount() + 're-entering createAsyncGenerator')
console.log(getCount() + 'exiting createAsyncGenerator')
}
const main = async () => {
console.log(getCount() + 'entering main')
const asyncGenerator = createAsyncGenerator()
console.log(getCount() + 'starting for await loop')
for await(const item of asyncGenerator) {
console.log(getCount() + 'entering for await loop')
console.log(getCount() + item)
console.log(getCount() + 'exiting for await loop')
}
console.log(getCount() + 'done with for await loop')
console.log(getCount() + 'leaving main')
}
console.log(getCount() + 'before calling main')
main()
console.log(getCount() + 'after calling main')Nach dem Login kopieren
Nach dem Login kopieren
这段代码你用了编号的日志记录语句，可让你跟踪其执行情况。作为练习，你需要自己运行程序然后查看执行结果是怎样的。
如果你不知道它的工作方式，就会使程序的执行产生混乱，但异步迭代的确是一项强大的技术。
更多编程相关知识，请访问：编程入门！！
Das obige ist der detaillierte Inhalt vonEin tiefer Einblick in asynchrone Generatoren und asynchrone Iteration in Node.js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
