Promise.resolve()

value

Argument, das von diesem 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 als Wert übergebene Promise, wenn der Wert ein Promise-Objekt war. Ein aufgelöstes Promise kann sich in jedem Zustand befinden — erfüllt, abgelehnt oder ausstehend. Zum Beispiel wird das Auflösen eines abgelehnten Promises ebenfalls 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. Siehe Beschreibung von Promise 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 Subclassing, was bedeutet, dass es auf Subklassen von Promise aufgerufen werden kann und das Ergebnis ein Promise des Subklassen-Typs ist. Dafür muss der Konstruktor der Subklasse dieselbe Signatur wie der Promise()-Konstruktor implementieren — das Akzeptieren einer einzigen executor-Funktion, die mit den resolve- und reject-Callbacks als Parameter aufgerufen werden kann.

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

Der Hauptteil der Logik zur Auflösung wird tatsächlich von der resolve-Funktion implementiert, 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 Thenable übergeben wird, nimmt das zurückgegebene Promise den Zustand dieses Thenables an, indem es die then-Methode aufruft und ein Paar auflösender Funktionen als Argumente übergibt. (Aber da native Promises direkt durch Promise.resolve() ohne Wrapper durchgereicht werden, wird die then-Methode nicht auf nativen Promises aufgerufen.) Wenn die resolve-Funktion ein anderes Thenable-Objekt erhält, wird es erneut aufgelöst, sodass der endgültige Erfüllungswert des Promises niemals ein Thenable sein wird.

Promise.resolve() verwendet bestehende 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 invertierte Reihenfolge der Konsolenausgaben 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
  },
);

Geschachtelte Thenables werden "tiefgehend reduziert" auf ein einzelnes 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 auf jedem Konstruktor aufgerufen werden, der dieselbe Signatur wie der Promise()-Konstruktor implementiert. Zum Beispiel können wir sie auf einem Konstruktor aufrufen, der console.log als resolve weitergibt:

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, geschachtelte Thenables zu reduzieren, wird von der resolve-Funktion des Promise()-Konstruktors implementiert. Wenn Sie sie auf einem anderen Konstruktor aufrufen, könnten geschachtelte Thenables je nach Implementierung der resolve-Funktion dieses Konstruktors möglicherweise nicht reduziert werden.

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