async function*

Probieren Sie es aus

async function* foo() {
  yield await Promise.resolve("a");
  yield await Promise.resolve("b");
  yield await Promise.resolve("c");
}

let str = "";

async function generate() {
  for await (const val of foo()) {
    str += val;
  }
  console.log(str);
}

generate();
// Expected output: "abc"

Syntax

async function* name(param0) {
  statements
}
async function* name(param0, param1) {
  statements
}
async function* name(param0, param1, /* , */ paramN) {
  statements
}

Parameter

name

Der Funktionsname.

param Optional

Der Name eines formalen Parameters fr die Funktion. Informationen zur Syntax der Parameter finden Sie im Funktionsleitfaden.

statements Optional

Die Anweisungen, die den Krper der Funktion bilden.

Beschreibung

Eine async function* Deklaration erstellt ein AsyncGeneratorFunction Objekt. Jedes Mal, wenn eine asynchrone Generatorfunktion aufgerufen wird, gibt sie ein neues AsyncGenerator Objekt zurck, das dem asynchronen Iterator-Protokoll entspricht. Jeder Aufruf von next() gibt ein Promise zurck, das sich auf das Iterator-Ergebnisobjekt auflst.

Eine asynchrone Generatorfunktion kombiniert die Merkmale von asynchronen Funktionen und Generatorfunktionen. Sie knnen sowohl die Schlsselwrter await als auch yield innerhalb des Funktionskrpers verwenden. Dies ermglicht es Ihnen, asynchrone Aufgaben auf ergonomische Weise mit await zu bearbeiten, whrend Sie die trge Natur von Generatorfunktionen nutzen.

Wenn ein Promise aus einem asynchronen Generator bergeben wird, wird der endgltige Zustand des Iterator-Ergebnis-Promises dem des bergebenen Promises entsprechen. Zum Beispiel:

async function* foo() {
  yield Promise.reject(new Error("failed"));
}

foo()
  .next()
  .catch((e) => console.error(e));

Error: failed wird protokolliert, da wenn das bergebene Promise abgelehnt wird, das Iterator-Ergebnis ebenfalls abgelehnt wird. Die value-Eigenschaft des aufgelsten Ergebnisses eines asynchronen Generators wird kein weiteres Promise sein.

async function* Deklarationen verhalten sich hnlich wie function Deklarationen sie werden gehoisted an den Anfang ihres Bereichs und knnen berall in ihrem Bereich aufgerufen werden, und sie knnen nur in bestimmten Kontexten erneut deklariert werden.

Beispiele

Deklarieren einer asynchronen Generatorfunktion

Asynchrone Generatorfunktionen erzeugen immer Promises von Ergebnissen sogar wenn jeder yield Schritt synchron ist.

async function* myGenerator(step) {
  await new Promise((resolve) => setTimeout(resolve, 10));
  yield 0;
  yield step;
  yield step * 2;
}

const gen = myGenerator(2);
gen
  .next()
  .then((res) => {
    console.log(res); // { value: 0, done: false }
    return gen.next();
  })
  .then((res) => {
    console.log(res); // { value: 2, done: false }
    return gen.next();
  })
  .then((res) => {
    console.log(res); // { value: 4, done: false }
    return gen.next();
  })
  .then((res) => {
    console.log(res); // { value: undefined, done: true }
    return gen.next();
  });

Verwenden einer asynchronen Generatorfunktion zum Lesen einer Reihe von Dateien

In diesem Beispiel lesen wir eine Reihe von Dateien und greifen nur auf deren Inhalt zu, wenn dies angefordert wird, mit Hilfe des Node fs/promises Moduls.

async function* readFiles(directory) {
  const files = await fs.readdir(directory);
  for (const file of files) {
    const stats = await fs.stat(file);
    if (stats.isFile()) {
      yield {
        name: file,
        content: await fs.readFile(file, "utf8"),
      };
    }
  }
}

const files = readFiles(".");
console.log((await files.next()).value);
// Possible output: { name: 'file1.txt', content: '...' }
console.log((await files.next()).value);
// Possible output: { name: 'file2.txt', content: '...' }

Spezifikationen

Browser-Kompatibilitt

Siehe auch

• Funktionen Leitfaden
• Iteratoren und Generatoren Leitfaden
• Funktionen
• AsyncGeneratorFunction
• async function* Ausdruck
• function
• function*
• async function
• Iterationsprotokolle
• yield
• yield*
• AsyncGenerator