Promise.resolve()

value

Argument, das durch dieses Promise aufgelöst wird. Kann auch ein Promise oder ein thenable sein, das aufgelöst werden soll.

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 einem beliebigen Zustand befinden – erfüllt, abgelehnt oder ausstehend. Zum Beispiel führt das Auflösen eines abgelehnten Promises immer noch zu einem abgelehnten Promise.

Promise.resolve() löst ein Promise auf, was nicht dasselbe ist wie das Erfüllen oder Ablehnen des Promises. Siehe 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.

Promise.resolve() ist generisch und unterstützt Subklassenbildung, was bedeutet, dass es auf Subklassen von Promise aufgerufen werden kann, und das Ergebnis wird ein Promise des Subklassen-Typs sein. Dafür muss der Konstruktor der Subklasse die gleiche Signatur wie der Promise()-Konstruktor implementieren — also eine einzelne executor-Funktion akzeptieren, die mit den resolve- und reject-Rückrufen als Parameter aufgerufen werden kann.

Promise.resolve() behandelt native Promise-Instanzen speziell. Wenn value zu Promise oder einer Subklasse gehört und value.constructor === Promise, dann wird value direkt von Promise.resolve() zurückgegeben, ohne eine neue Promise-Instanz zu erstellen. Andernfalls ist Promise.resolve() im Wesentlichen eine Abkürzung für new Promise((resolve) => resolve(value)).

Der Großteil der Löselogik wird tatsächlich von der resolve-Funktion implementiert, die vom Promise()-Konstruktor übergeben wird. Zusammenfassend:

• Wenn ein nicht-thenable Wert übergeben wird, ist das zurückgegebene Promise bereits mit diesem Wert erfüllt.
• Wenn ein thenable übergeben wird, wird das zurückgegebene Promise den Zustand dieses thenables annehmen, indem die then-Methode aufgerufen wird und ein Paar von Lösungsmethoden als Argumente übergeben wird. (Da native Promises direkt durch Promise.resolve() ohne Erstellung eines Wrappers durchgehen, wird die then-Methode auf nativen Promises nicht aufgerufen.) Wenn die resolve-Funktion ein weiteres thenable Objekt erhält, wird es erneut aufgelöst, so dass der endgültige Erfüllungswert des Promises niemals ein thenable sein wird.

Promise.resolve() verwendet vorhandene Promise-Instanzen wieder. Wenn es ein natives Promise auflöst, gibt es dieselbe Promise-Instanz zurück, ohne einen Wrapper zu erstellen.

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

Die umgekehrte Reihenfolge der Logs ist darauf zurückzuführen, dass die then-Handler asynchron aufgerufen werden. Für weitere Informationen siehe die then()-Referenz.

// 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
  },
);

Geschachtelte thenables werden zu einem einzelnen Promise "tief reduziert".

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

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

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

Promise.resolve() ist eine generische Methode. Es kann auf jedem Konstruktor aufgerufen werden, der dieselbe Signatur wie der Promise()-Konstruktor implementiert. Zum Beispiel können wir es auf einen Konstruktor aufrufen, der console.log als resolve übergibt:

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

Promise.resolve.call(NotPromise, "foo"); // Logs "Resolved foo"

Die Fähigkeit, verschachtelte thenables zu reduzieren, wird von der resolve-Funktion des Promise()-Konstruktors implementiert, sodass, wenn Sie es auf einen anderen Konstruktor aufrufen, verschachtelte thenables möglicherweise nicht reduziert werden, abhängig davon, wie dieser Konstruktor seine resolve-Funktion implementiert.

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

Promise.resolve.call(NotPromise, thenable); // Logs "Resolved { then: [Function: then] }"

• Promise