Promise.resolve() — Methode · JavaScript-Referenz

Signatur

Promise.resolve(value)

Beschreibung

Die statische Methode Promise.resolve() „löst" einen gegebenen Wert zu einem Promise auf. Ist der Wert ein Promise, wird dieses Promise zurückgegeben; ist der Wert ein thenable, ruft Promise.resolve() dessen then()-Methode mit zwei vorbereiteten callbacks auf; andernfalls wird das zurückgegebene Promise mit dem Wert erfüllt (fulfilled).

Diese Funktion flacht verschachtelte Schichten von promise-artigen Objekten (z. B. ein Promise, das zu einem Promise erfüllt wird, das zu etwas erfüllt wird) zu einer einzigen Schicht ab — ein Promise, das zu einem nicht-thenable Wert erfüllt wird.

Beschreibung

Promise.resolve() löst ein Promise auf (resolves), was nicht dasselbe ist wie das Erfüllen (fulfilling) oder Ablehnen (rejecting) des Promises. Siehe die Promise-Beschreibung für Definitionen der Terminologie. Kurz gesagt: Promise.resolve() gibt ein Promise zurück, dessen späterer Zustand von einem anderen Promise, thenable-Objekt oder einem anderen Wert abhängt.

Hinweis: Wenn die Auswertung des value-Ausdrucks synchron einen Fehler werfen kann, wird dieser Fehler von Promise.resolve() nicht abgefangen und in ein abgelehntes Promise verpackt. In diesem Fall sollte Promise.try(() => value) in Betracht gezogen werden.

Promise.resolve() ist generisch und unterstützt Subclassing, d. h. es kann auf Subklassen von Promise aufgerufen werden, und das Ergebnis ist ein Promise des Subklassen-Typs. Dazu muss der Konstruktor der Subklasse dieselbe Signatur wie der Promise()-Konstruktor implementieren — er muss eine einzige executor-Funktion akzeptieren, die mit den callbacks resolve und reject als Parameter aufgerufen werden kann.

Promise.resolve() behandelt native Promise-Instanzen als Sonderfall. Wenn value zu Promise oder einer Subklasse gehört und value.constructor === Promise gilt, wird value direkt von Promise.resolve() zurückgegeben, ohne dass eine neue Promise-Instanz erzeugt wird. Andernfalls ist Promise.resolve() im Wesentlichen eine Kurzform für new Promise((resolve) => resolve(value)).

Der Großteil der Auflösungs-Logik wird eigentlich von der resolve-Funktion implementiert, die vom Promise()-Konstruktor übergeben wird. Zusammengefasst:

Wird ein nicht-thenable Wert übergeben, ist das zurückgegebene Promise bereits mit diesem Wert erfüllt.
Wird ein thenable übergeben, übernimmt das zurückgegebene Promise den Zustand dieses thenable, indem die then-Methode aufgerufen und ein Paar von Auflösungsfunktionen als Argumente übergeben wird. (Da native Promises jedoch direkt durch Promise.resolve() hindurchgereicht werden, ohne einen Wrapper zu erzeugen, wird die then-Methode bei nativen Promises nicht aufgerufen.) Erhält die resolve-Funktion ein weiteres thenable-Objekt, wird dieses erneut aufgelöst, sodass der letztendliche Erfüllungswert des Promises niemals thenable sein wird.

Parameter

Name	Typ	Default	Beschreibung
$value Pflicht	any	—	Argument, das von diesem `Promise` aufgelöst werden soll. Kann auch ein `Promise` oder ein thenable sein, das aufgelöst werden soll.

Rückgabewert

Typ

Promise

Beschreibung

Ein Promise, das mit dem gegebenen Wert aufgelöst wird, oder das als Wert übergebene Promise, falls der Wert ein Promise-Objekt war. Ein aufgelöstes Promise kann sich in jedem der Zustände befinden — fulfilled, rejected oder pending. Zum Beispiel führt das Auflösen eines abgelehnten Promises immer noch zu einem abgelehnten Promise.

Beispiele

Verwenden der statischen Methode Promise.resolve

Promise.resolve("Success").then(
  (value) => {
    console.log(value); // "Success"
  },
  (reason) => {
    // not called
  },
);

Ein Array auflösen

const p = Promise.resolve([1, 2, 3]);
p.then((v) => {
  console.log(v[0]); // 1
});

Ein anderes Promise auflösen

const original = Promise.resolve(33);
const cast = Promise.resolve(original);
cast.then((value) => {
  console.log(`value: ${value}`);
});
console.log(`original === cast ? ${original === cast}`);

// Logs, in order:
// original === cast ? true
// value: 33

Thenables auflösen und Errors werfen

// Resolving a thenable object
const p1 = Promise.resolve({
  then(onFulfill, onReject) {
    onFulfill("fulfilled!");
  },
});
console.log(p1 instanceof Promise); // true, object casted to a Promise

p1.then(
  (v) => {
    console.log(v); // "fulfilled!"
  },
  (e) => {
    // not called
  },
);

// Thenable throws
// Promise rejects
const p2 = Promise.resolve({
  then() {
    throw new TypeError("Throwing");
  },
});
p2.then(
  (v) => {
    // not called
  },
  (e) => {
    console.error(e); // TypeError: Throwing
  },
);

// Thenable throws after callback
// Promise resolves
const p3 = Promise.resolve({
  then(onFulfilled) {
    onFulfilled("Resolving");
    throw new TypeError("Throwing");
  },
});
p3.then(
  (v) => {
    console.log(v); // "Resolving"
  },
  (e) => {
    // not called
  },
);

Verschachtelte thenables tief abflachen

const thenable = {
  then(onFulfilled, onRejected) {
    onFulfilled({
      // The thenable is fulfilled with another thenable
      then(onFulfilled, onRejected) {
        onFulfilled(42);
      },
    });
  },
};

Promise.resolve(thenable).then((v) => {
  console.log(v); // 42
});

Unendliche Rekursion (schlechtes Beispiel)

const thenable = {
  then(onFulfilled, onRejected) {
    onFulfilled(thenable);
  },
};

Promise.resolve(thenable); // Will lead to infinite recursion.

resolve() auf einem Nicht-Promise-Konstruktor aufrufen

class NotPromise {
  constructor(executor) {
    // The "resolve" and "reject" functions behave nothing like the
    // native promise's, but Promise.resolve() calls them in the same way.
    executor(
      (value) => console.log("Resolved", value),
      (reason) => console.log("Rejected", reason),
    );
  }

  static resolve = Promise.resolve;
}

const p = NotPromise.resolve("foo"); // Logs "Resolved foo"
// p is a NotPromise instance

Nicht abgeflachte thenables bei anderem Konstruktor

const thenable = {
  then(onFulfilled, onRejected) {
    onFulfilled({
      // The thenable is fulfilled with another thenable
      then(onFulfilled, onRejected) {
        onFulfilled(42);
      },
    });
  },
};

const p = NotPromise.resolve(thenable); // Logs "Resolved { then: [Function: then] }"
// p is a NotPromise instance

// Wichtig · Fallstricke

Rufen Sie Promise.resolve() nicht auf einem thenable auf, das zu sich selbst aufgelöst wird. Das führt zu unendlicher Rekursion, da versucht wird, ein unendlich verschachteltes Promise abzuflachen.

Siehe auch

Promise

← Vorheriger Eintrag Promise.reject() Nächster Eintrag → Promise.try()