KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / JavaScript

De resolve- en reject-functies van de Promise-executor

De Promise-constructor geeft de executor twee functies. De eerste aanroep van een van beide legt de uitkomst vast, maar de promise kan nog in afwachting blijven.

Versie: ECMAScript 2024 and the current web platform; runtime support varies

Syntax

new Promise((resolve, reject) => { /* Call resolve(value) or reject(reason). */ });

new Promise(executor) vereist een functie en roept die synchroon aan met eerst resolve en dan reject. Dat zijn gebruikelijke parameternamen; elk paar hoort bij één nieuw aangemaakte promise. Beide functies geven undefined terug en kunnen worden bewaard voor een latere aanroep, bijvoorbeeld in een callback. De statische methoden Promise.resolve() en Promise.reject() geven daarentegen promises terug.

resolve(value) vervult de promise onmiddellijk met de waarde als die primitief is. Geef je de promise aan zijn eigen resolve door, dan wordt die afgewezen met een TypeError. Bij elk ander object leest JavaScript de eigenschap then synchroon. Is de gelezen waarde niet aanroepbaar, dan wordt de promise meteen vervuld met het object zelf, ook als dat een andere promise is. Is de gelezen waarde wel aanroepbaar, dan is het object een thenable: JavaScript roept then pas later aan. De promise volgt de uitkomst van de thenable en kan in afwachting blijven. Een uitzondering bij het lezen van then, of bij het aanroepen ervan voordat een van de meegegeven callbacks is aangeroepen, leidt ook tot afwijzing.

reject(reason) wijst de promise meteen af met de opgegeven reden en volgt de uitkomst daarvan niet, ook niet als de reden een promise is. Elke waarde mag, maar een Error is meestal nuttiger. Laat je het argument weg, dan wordt undefined gebruikt. Alleen de eerste aanroep van een van beide functies telt, ook als de promise nog in afwachting is. De uitkomst ligt vast (resolved), maar de promise is pas afgerond (settled) nadat die is vervuld of afgewezen. Handlers die met then() en catch() zijn geregistreerd, draaien asynchroon.

De constructor negeert de retourwaarde van de executor. Een uitzondering die synchroon uit de executor komt, wijst de promise alleen af als geen van beide functies is aangeroepen. Wordt geen van beide ooit aangeroepen en gooit de executor geen uitzondering, dan blijft de promise in afwachting. Vermijd een async-executor: de constructor negeert de promise die deze teruggeeft, dus afwijzing daarvan wijst de buitenste promise niet af.

Voorbeelden

{
  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);
}

Resultaat

executor
after constructor
fulfilled: 42
rejected: failed

`executor` verschijnt vóór `after constructor` omdat de executor synchroon draait. `resolve(inner)` legt de uitkomst van `outer` vast terwijl `inner` nog in afwachting is, dus `reject(new Error("ignored"))` heeft geen effect. `finish(42)` vervult `inner`; de handler toont `fulfilled: 42` en daarna verwerkt `catch()` de afwijzing van een afzonderlijke promise met het bericht `failed`.

Gerelateerde lessen

  • JavaScript · Les 14 · Gemiddeld · Versie: 3
  • JavaScript · Les 15 · Gemiddeld · Versie: 3

Bronnen