Promise.resolve()

value

Argument, das durch dieses Promise aufgelöst werden soll. 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 Promise, das als Wert übergeben wurde, falls der Wert ein Promise-Objekt war. Ein aufgelöstes Promise kann in jedem Zustand sein — erfüllt, abgelehnt oder ausstehend. Zum Beispiel wird das Auflösen eines abgelehnten Promises trotzdem zu einem abgelehnten Promise führen.

Promise.resolve() löst ein Promise, was nicht dasselbe wie die Erfüllung oder Ablehnung des Promises ist. Siehe Promise-Beschreibung für Definitionen der Terminologie. Kurz gesagt, Promise.resolve() gibt ein Promise zurück, dessen endgültiger Zustand von einem anderen Promise, einem thenable Objekt oder einem anderen Wert abhängt.

Promise.resolve() ist generisch und unterstützt Unterklassen, was bedeutet, dass es auf Unterklassen von Promise aufgerufen werden kann, und das Ergebnis wird ein Promise des Unterklassen-Typs sein. Dazu muss der Konstruktor der Unterklasse die gleiche Signatur wie der Promise() Konstruktor implementieren — 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 Unterklasse 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 Auflösungslogik wird tatsächlich von der resolve Funktion durchgeführt, die vom Promise() Konstruktor übergeben wird. Zusammengefasst:

• Wenn ein nicht-thenable Wert übergeben wird, ist das zurückgegebene Promise bereits mit diesem Wert erfüllt.
• Wenn ein dannable übergeben wird, nimmt das zurückgegebene Promise den Zustand dieses dannables an, indem es die then Methode aufruft und ein Paar von Auflösungsfunktionen als Argumente übergibt. (Da native Promises direkt durch Promise.resolve() hindurchgehen, ohne einen Wrapper zu erstellen, wird die then Methode nicht auf nativen Promises 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 thenable sein wird.

Promise.resolve() verwendet vorhandene Promise Instanzen. Wenn ein natives Promise aufgelöst wird, gibt es die gleiche 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 liegt daran, dass die then Handler asynchron aufgerufen werden. Weitere Informationen finden Sie in der 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
  },
);

Verschachtelte thenables werden zu einem einzelnen Promise "tief abgeflacht".

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. Sie kann auf jedem Konstruktor aufgerufen werden, der die gleiche Signatur wie der Promise() Konstruktor implementiert. Zum Beispiel können wir sie auf einem 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 abzuflachen, wird von der resolve Funktion des Promise() Konstruktors implementiert. Wenn Sie es auf einen anderen Konstruktor aufrufen, werden verschachtelte thenables möglicherweise nicht abgeflacht, 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