value

Argument, das von diesemPromise aufgelöst werden soll. Kann auch einPromise oder ein thenable sein, das aufgelöst werden soll.

EinPromise, das mit dem gegebenen Wert aufgelöst wird oder das Promise, das als Wert übergeben wurde, wenn der Wert ein Promise-Objekt war. Ein aufgelöstes Promise kann in jedem der Zustände sein — erfüllt, abgelehnt oder ausstehend. Zum Beispiel wird das Auflösen eines abgelehnten Promises immer noch zu einem abgelehnten Promise führen.

Promise.resolve()löst ein Promise auf, was nicht dasselbe ist wie das Erfüllen oder Ablehnen des Promises. Weitere Definitionen der Terminologie finden Sie in derBeschreibung von Promise. Kurz gesagt gibtPromise.resolve() ein Promise zurück, dessen endgültiger Zustand von einem anderen Promise, thenable Objekt oder einem anderen Wert abhängt.

Promise.resolve() ist generisch und unterstützt die Unterklassenbildung, was bedeutet, dass es auf Unterklassen vonPromise aufgerufen werden kann und das Ergebnis ein Promise des Unterklassentyps sein wird. Hierfür muss der Konstruktor der Unterklasse die gleiche Signatur wie derPromise()-Konstruktor implementieren — das Akzeptieren einer einzelnenexecutor-Funktion, die mit denresolve- undreject-Rückrufen als Parameter aufgerufen werden kann.

Promise.resolve() behandelt nativePromise-Instanzen speziell. Wennvalue zuPromise oder einer Unterklasse gehört undvalue.constructor === Promise, wirdvalue direkt vonPromise.resolve() zurückgegeben, ohne eine neuePromise-Instanz zu erstellen. Andernfalls istPromise.resolve() im Wesentlichen eine Kurzform fürnew Promise((resolve) => resolve(value)).

Der Großteil der Auflösungslogik wird tatsächlich von derderresolve-Funktion implementiert, die vomPromise()-Konstruktor übergeben wird. Zusammengefasst:

• Wenn ein nicht-thenable-Wert übergeben wird, ist das zurückgegebene Promise bereits mit diesem Wert erfüllt.
• Wenn ein thenable übergeben wird, übernimmt das zurückgegebene Promise den Zustand dieses thenable, indem diethen-Methode aufgerufen und ein Paar von Auflösungsfunktionen als Argumente übergeben werden. (Da jedoch native Promises direkt überPromise.resolve() ohne die Erstellung eines Wrappers durchlaufen werden, wird diethen-Methode nicht für native Promises aufgerufen.) Wenn dieresolve-Funktion ein weiteres thenable-Objekt erhält, wird es erneut aufgelöst, sodass der letztendliche Erfüllungswert des Promises niemals thenable sein wird.

Promise.resolve() verwendet bestehendePromise-Instanzen wieder. Wenn es ein natives Promise auflöst, wird die gleiche Promise-Instanz zurückgegeben, 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 Protokolle liegt daran, dass diethen-Handler asynchron aufgerufen werden. Weitere Informationen finden Sie in derthen()-Referenz.

// Resolving a thenable objectconst p1 = Promise.resolve({  then(onFulfill, onReject) {    onFulfill("fulfilled!");  },});console.log(p1 instanceof Promise); // true, object casted to a Promisep1.then(  (v) => {    console.log(v); // "fulfilled!"  },  (e) => {    // not called  },);// Thenable throws// Promise rejectsconst p2 = Promise.resolve({  then() {    throw new TypeError("Throwing");  },});p2.then(  (v) => {    // not called  },  (e) => {    console.error(e); // TypeError: Throwing  },);// Thenable throws after callback// Promise resolvesconst p3 = Promise.resolve({  then(onFulfilled) {    onFulfilled("Resolving");    throw new TypeError("Throwing");  },});p3.then(  (v) => {    console.log(v); // "Resolving"  },  (e) => {    // not called  },);

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

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 bei jedem Konstruktor aufgerufen werden, der die gleiche Signatur wie derPromise()-Konstruktor implementiert. Zum Beispiel können wir sie bei einem Konstruktor aufrufen, derconsole.log alsresolve ü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 derresolve-Funktion desPromise()-Konstruktors implementiert. Wenn Sie sie bei einem anderen Konstruktor aufrufen, werden verschachtelte thenables möglicherweise nicht abgeflacht, je nachdem, wie dieser Konstruktor seineresolve-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