CKTIS / JavaScript
Die Funktionen resolve und reject im Promise-Executor
Der Promise-Konstruktor übergibt dem Executor zwei Funktionen. Der erste Aufruf legt das Ergebnis des Promise fest, ohne es zwangsläufig sofort abzuschließen.
Version: ECMAScript 2024 and the current web platform; runtime support varies
Syntax
new Promise((resolve, reject) => { /* Call resolve(value) or reject(reason). */ });new Promise(executor) erwartet eine Funktion und ruft sie synchron auf: zuerst mit resolve, dann mit reject. Das sind übliche Parameternamen; jedes Funktionspaar gehört zu genau einem neu erzeugten Promise. Beide Funktionen geben undefined zurück und lassen sich für einen späteren Aufruf speichern, etwa in einer Callback-Funktion. Die statischen Methoden Promise.resolve() und Promise.reject() geben dagegen Promises zurück.
resolve(value) erfüllt das Promise sofort, wenn der übergebene Wert primitiv ist. Übergibt man das Promise an sein eigenes resolve, wird es mit einem TypeError abgelehnt. Bei jedem anderen Objekt liest JavaScript die Eigenschaft then synchron. Ist der gelesene Wert nicht aufrufbar, wird das Promise sofort mit dem Objekt selbst erfüllt, auch wenn dieses ein anderes Promise ist. Ist der gelesene Wert aufrufbar, ist das Objekt ein Thenable: JavaScript ruft then erst später auf. Das Promise übernimmt das Ergebnis des Thenables und kann weiter ausstehen. Eine Ausnahme beim Lesen von then oder beim Aufruf, bevor einer der an then übergebenen Callbacks aufgerufen wurde, führt ebenfalls zur Ablehnung.
reject(reason) lehnt das Promise sofort mit dem angegebenen Grund ab, auch wenn der Grund selbst ein Promise ist: Dessen Ergebnis wird nicht übernommen. Jeder Wert ist zulässig, aber ein Error ist meist hilfreicher. Ohne Argument gilt undefined. Nur der erste Aufruf einer der beiden Funktionen zählt, auch wenn das Promise noch aussteht. Das Ergebnis ist festgelegt (resolved), abgeschlossen (settled) ist das Promise aber erst, wenn es erfüllt oder abgelehnt ist. Mit then() und catch() registrierte Handler laufen asynchron.
Der Konstruktor ignoriert den Rückgabewert des Executors. Eine Ausnahme, die den Executor synchron verlässt, lehnt das Promise nur ab, wenn keine der beiden Funktionen bereits aufgerufen wurde. Wird keine von beiden jemals aufgerufen und löst der Executor keine Ausnahme aus, bleibt das Promise ausstehend. Vermeide einen async-Executor: Der Konstruktor ignoriert dessen zurückgegebenes Promise, sodass dessen Ablehnung das äußere Promise nicht ablehnt.
Beispiele
{
let finish;
const inner = new Promise((resolve) => {
finish = resolve;
});
const outer = new Promise((resolve, reject) => {
console.log("executor");
resolve(inner);
reject(new Error("ignored"));
});
console.log("after constructor");
outer.then((value) => {
console.log(`fulfilled: ${value}`);
return new Promise((resolve, reject) => {
reject(new Error("failed"));
});
}).catch((reason) => {
console.log(`rejected: ${reason.message}`);
});
finish(42);
}Ergebnis
executor after constructor fulfilled: 42 rejected: failed
`executor` erscheint vor `after constructor`, weil der Executor synchron läuft. `resolve(inner)` legt das Ergebnis von `outer` fest, während `inner` noch aussteht. Daher bleibt `reject(new Error("ignored"))` wirkungslos. `finish(42)` erfüllt `inner`; der Handler gibt `fulfilled: 42` aus, und `catch()` behandelt danach die Ablehnung eines separaten Promise mit der Meldung `failed`.
Zugehörige Lektionen
- JavaScript · Lektion 14 · Mittlere Stufe · Version: 3
- JavaScript · Lektion 15 · Mittlere Stufe · Version: 3