AsyncFunction — Klasse · JavaScript-Referenz

Signatur

class AsyncFunction extends Function

Beschreibung

AsyncFunction ist der Konstruktor, von dem alle mit dem async function-Schlüsselwort deklarierten Funktionen abstammen. Er ist nicht direkt als globales Symbol verfügbar, kann aber über Object.getPrototypeOf(async function(){}).constructor ermittelt werden. Über new AsyncFunction(...args, body) lassen sich asynchrone Funktionen zur Laufzeit aus Zeichenketten erzeugen – ähnlich wie eval, aber als eigenständiges Funktionsobjekt.

Jede mit async function definierte Funktion ist eine Instanz von AsyncFunction. Sie gibt stets ein Promise zurück: Wird im Rumpf ein Wert zurückgegeben, erfüllt sich das Promise mit diesem Wert; wirft die Funktion einen Fehler, lehnt das Promise ab. Innerhalb des Rumpfes kann await verwendet werden, um auf andere Promises zu warten.

Die Verwendung des AsyncFunction-Konstruktors mit Zeichenketten-Code ist aus Sicherheitsgründen problematisch – sie ähnelt eval und umgeht Content-Security-Policies. In normalen Anwendungsfällen sollte stattdessen die async function-Syntax bevorzugt werden. Der dynamische Konstruktor ist nur dann sinnvoll, wenn Funktionskörper wirklich erst zur Laufzeit bekannt sind.

Prototype-Kette: AsyncFunction.prototype → Function.prototype → Object.prototype
Instanceof-Prüfung: async function f(){} instanceof AsyncFunction ergibt true

Parameter

Name	Typ	Default	Beschreibung
$...args	string		Null oder mehr Parameternamen als Zeichenketten, die der erzeugten Funktion übergeben werden sollen.
$body Pflicht	string		Der Quellcode des Funktionsrumpfes als Zeichenkette. Darf `await`-Ausdrücke enthalten.

Rückgabewert

Typ

AsyncFunction

Beschreibung

Gibt eine neue asynchrone Funktion zurück, deren Aufruf stets ein Promise liefert. Das Promise erfüllt sich mit dem Rückgabewert des Rumpfes oder lehnt bei einer geworfenen Ausnahme ab.

Beispiele

Asynchrone Funktion mit async/await-Syntax

// Typische Verwendung: async function-Syntax
const fetchUser = async (id) => {
  const response = await fetch(`https://jsonplaceholder.typicode.com/users/${id}`);
  if (!response.ok) throw new Error(`HTTP-Fehler: ${response.status}`);
  const user = await response.json();
  return user.name;
};

fetchUser(1)
  .then(name => console.log('Benutzername:', name))
  .catch(err => console.error('Fehler:', err.message));

Benutzername: Leanne Graham

Dynamische AsyncFunction mit dem Konstruktor

// AsyncFunction-Konstruktor abrufen
const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;

// Dynamisch eine asynchrone Funktion erzeugen
const dynamicAsync = new AsyncFunction(
  'url',
  `
    const res = await fetch(url);
    const data = await res.json();
    return data.id;
  `
);

// Verwendung wie jede andere async-Funktion
dynamicAsync('https://jsonplaceholder.typicode.com/todos/1')
  .then(id => console.log('ID:', id))
  .catch(err => console.error(err));

// Instanceof-Prüfung
console.log(dynamicAsync instanceof AsyncFunction); // true
console.log(dynamicAsync instanceof Function);      // true

ID: 1 true true

Fehlerbehandlung in async-Funktionen

const parseJSON = async (text) => {
  try {
    return JSON.parse(text);
  } catch (e) {
    throw new TypeError(`Ungültiges JSON: ${e.message}`);
  }
};

// Gültiges JSON
parseJSON('{"key": 42}').then(val => console.log(val)); // { key: 42 }

// Ungültiges JSON – Promise lehnt ab
parseJSON('kein json')
  .catch(err => console.error(err.message));

{ key: 42 } Ungültiges JSON: Unexpected token k in JSON at position 0

// Wichtig · Fallstricke

Sicherheit: Die Verwendung von new AsyncFunction(codeString) ist ähnlich gefährlich wie eval(). Der übergebene Code wird im globalen Gültigkeitsbereich ausgeführt und hat keinen Zugriff auf den lokalen Closure-Scope. Externe oder nutzerkontrollierte Eingaben dürfen niemals direkt als Funktionskörper übergeben werden (XSS-Risiko). Außerdem kann diese Technik durch Content-Security-Policies (CSP) mit script-src 'unsafe-eval' blockiert werden.

Gültigkeitsbereich: Dynamisch erzeugte AsyncFunction-Instanzen schließen keine Variablen aus dem umgebenden Scope ein – sie laufen im globalen Scope. Dies unterscheidet sie von normalen async function-Ausdrücken.

Browser-Kompatibilität: async/await und AsyncFunction sind seit ES2017 in allen modernen Browsern und in Node.js ab Version 7.6 verfügbar.

Siehe auch

async function await Promise Function GeneratorFunction AsyncGeneratorFunction