DerPromise()-Konstruktor erstelltPromise-Objekte. Er wird hauptsächlich verwendet, um APIs, die auf Rückrufmethoden basieren und keine Unterstützung für Promises haben, zu erweitern.

Probieren Sie es aus

const promise1 = new Promise((resolve, reject) => {  setTimeout(() => {    resolve("foo");  }, 300);});promise1.then((value) => {  console.log(value);  // Expected output: "foo"});console.log(promise1);// Expected output: [object Promise]

Syntax

new Promise(executor)

Parameter

executor

Einefunction, die vom Konstruktor ausgeführt wird. Sie erhält zwei Funktionen als Parameter:resolveFunc undrejectFunc. Alle imexecutor ausgelösten Fehler führen dazu, dass das Promise abgelehnt wird, und der Rückgabewert wird ignoriert. Die Semantik vonexecutor wird unten detailliert beschrieben.

Rückgabewert

Bei einem Aufruf übernew gibt derPromise-Konstruktor ein Promise-Objekt zurück. Das Promise-Objekt wirdaufgelöst, wenn eine der FunktionenresolveFunc oderrejectFunc aufgerufen wird. Beachten Sie, dass wenn SieresolveFunc aufrufen und ein anderes Promise-Objekt als Argument übergeben, das ursprüngliche Promise als "aufgelöst" gilt, aber dennoch nicht "abgeschlossen". Siehe diePromise-Beschreibung für mehr Erklärungen.

Beschreibung

Traditionell (vor Promises) wurden asynchrone Aufgaben als Rückrufe entworfen.

readFile("./data.txt", (error, result) => {  // This callback will be called when the task is done, with the  // final `error` or `result`. Any operation dependent on the  // result must be defined within this callback.});// Code here is immediately executed after the `readFile` request// is fired. It does not wait for the callback to be called, hence// making `readFile` "asynchronous".

Um die Lesbarkeit zu verbessern und die Sprachmerkmale von Promises zu nutzen, ermöglicht derPromise()-Konstruktor, die auf Rückrufmethoden basierende API in eine Promise-basierte zu transformieren.

Derexecutor ist maßgeschneiderter Code, der ein Ergebnis in einem Rückruf mit einem Promise verknüpft. Sie, der Programmierer, schreiben denexecutor. Seine Signatur sollte wie folgt aussehen:

function executor(resolveFunc, rejectFunc) {  // Typically, some asynchronous operation that accepts a callback,  // like the `readFile` function above}

resolveFunc undrejectFunc sind ebenfalls Funktionen, und Sie können ihnen beliebige tatsächliche Namen geben. Ihre Signaturen sind einfach: Sie akzeptieren einen einzigen Parameter beliebigen Typs.

resolveFunc(value); // call on resolvedrejectFunc(reason); // call on rejected

Dervalue-Parameter, der anresolveFunc übergeben wird, kann ein weiteres Promise-Objekt sein, in diesem Fall wird der Status des neu erstellten Promises an das übergebene Promise (als Teil desAuflösungs-Promises) "gekoppelt".rejectFunc hat eine Semantik nahe derthrow-Anweisung, daher istreason typischerweise eine Instanz vonError. Wenn entwedervalue oderreason weggelassen werden, wird das Promise mitundefined erfüllt/abgelehnt.

Der Abschlusszustand desexecutor hat begrenzte Auswirkungen auf den Status des Promises:

• Der Rückgabewert desexecutor wird ignoriert.return-Anweisungen innerhalb desexecutor beeinflussen lediglich den Kontrollfluss und ändern, ob ein Teil der Funktion ausgeführt wird, haben jedoch keinen Einfluss auf den Erfüllungswert des Promises. Wennexecutor endet und es unmöglich ist, dassresolveFunc oderrejectFunc in Zukunft aufgerufen werden (zum Beispiel, wenn keine asynchronen Aufgaben geplant sind), bleibt das Promise für immer schwebend.
• Wenn imexecutor ein Fehler ausgelöst wird, wird das Promise abgelehnt, es sei denn,resolveFunc oderrejectFunc wurde bereits aufgerufen.

Hier ein Überblick über den typischen Ablauf:

1. Zu dem Zeitpunkt, an dem der Konstruktor das neuePromise-Objekt erzeugt, wird auch ein entsprechendes Paar von Funktionen fürresolveFunc undrejectFunc erzeugt; diese sind mit demPromise-Objekt "verbunden".
2. executor umschließt typischerweise einige asynchrone Vorgänge, die eine auf Rückrufmethoden basierende API bereitstellen. Der Rückruf (derjenige, der an die ursprüngliche Rückruf-basierte API übergeben wird) wird innerhalb desexecutor-Codes definiert, sodass er Zugriff aufresolveFunc undrejectFunc hat.
3. Derexecutor wird synchron aufgerufen (sobald dasPromise konstruiert ist) mit denresolveFunc- undrejectFunc-Funktionen als Argumente.
4. Der Code innerhalb desexecutor hat die Möglichkeit, eine Operation durchzuführen. Der eventuale Abschluss der asynchronen Aufgabe wird über die Nebenwirkungen, die vonresolveFunc oderrejectFunc verursacht werden, an die Promise-Instanz kommuniziert. Die Nebenwirkung besteht darin, dass dasPromise-Objekt "aufgelöst" wird.
   • WirdresolveFunc zuerst aufgerufen, wird der übergebene Wertaufgelöst. Das Promise kann weiterhin schwebend bleiben (falls ein anderesthenable übergeben wird), erfüllt werden (in den meisten Fällen, in denen ein nicht-thenable Wert übergeben wird) oder abgelehnt werden (bei einem ungültigen Auflösungswert).
   • WirdrejectFunc zuerst aufgerufen, wird das Promise sofort abgelehnt.
   • Sobald eine der auflösenden Funktionen (resolveFunc oderrejectFunc) aufgerufen wird, bleibt das Promise aufgelöst. Nur der erste Aufruf vonresolveFunc oderrejectFunc beeinflusst den endgültigen Zustand des Promises, und nachfolgende Aufrufe einer der Funktionen können weder den Erfüllungswert/die Ablehnungsursache ändern noch den endgültigen Zustand von "erfüllt" zu "abgelehnt" oder umgekehrt ändern.
   • Wennexecutor durch Werfen eines Fehlers beendet wird, wird das Promise abgelehnt. Der Fehler wird jedoch ignoriert, wenn eine der auflösenden Funktionen bereits aufgerufen wurde (so dass das Promise bereits aufgelöst ist).
   • Das Auflösen des Promises führt nicht notwendigerweise dazu, dass das Promise erfüllt oder abgelehnt wird (d.h. abgeschlossen). Das Promise kann weiterhin schwebend bleiben, weil es mit einem anderen Thenable aufgelöst ist, aber sein endgültiger Zustand wird dem des aufgelösten Thenable entsprechen.
5. Sobald das Promise abgeschlossen ist, ruft es (asynchron) alle weiteren Handler auf, die überthen(),catch() oderfinally() damit verbunden sind. Der letztendliche Erfüllungswert oder Ablehnungsgrund wird an die Ausführung der Erfüllungs- und Ablehnungshandler als Eingabeparameter übergeben (sieheVerkettete Promises).

Zum Beispiel kann die oben beschriebene Callback-basiertereadFile-API in eine promise-basierte umgewandelt werden.

const readFilePromise = (path) =>  new Promise((resolve, reject) => {    readFile(path, (error, result) => {      if (error) {        reject(error);      } else {        resolve(result);      }    });  });readFilePromise("./data.txt")  .then((result) => console.log(result))  .catch((error) => console.error("Failed to read data"));

Dieresolve- undreject-Rückrufe sind nur im Bereich der Executor-Funktion verfügbar, was bedeutet, dass Sie auf sie nicht zugreifen können, nachdem das Promise konstruiert wurde. Wenn Sie das Promise erstellen möchten, bevor Sie entscheiden, wie es aufgelöst wird, können Sie stattdessen diePromise.withResolvers()-Methode verwenden, die dieresolve- undreject-Funktionen bereitstellt.

Die resolve-Funktion

Dieresolve-Funktion hat die folgenden Verhalten:

• Wird sie mit dem gleichen Wert wie das neu erstellte Promise (das Promise, mit dem sie "verbunden" ist) aufgerufen, wird das Promise mit einemTypeError abgelehnt.
• Wird sie mit einem nicht-thenable Wert (einem primitiven Wert oder einem Objekt, dessenthen-Eigenschaft nicht aufrufbar ist, einschließlich wenn die Eigenschaft nicht vorhanden ist) aufgerufen, wird das Promise sofort mit diesem Wert erfüllt.
• Wird sie mit einem thenable Wert (einschließlich einer anderenPromise-Instanz) aufgerufen, wird diethen-Methode des Thenables gespeichert und in Zukunft aufgerufen (sie wird immer asynchron aufgerufen). Diethen-Methode wird mit zwei Rückrufen aufgerufen, bei denen es sich um zwei neue Funktionen mit genau demselben Verhalten wie dieresolveFunc undrejectFunc handelt, die an dieexecutor-Funktion übergeben werden. Wenn der Aufruf derthen-Methode zu einem Fehler führt, wird das aktuelle Promise mit dem ausgelösten Fehler abgelehnt.

Im letzten Fall bedeutet es, dass Code wie folgt ist:

new Promise((resolve, reject) => {  resolve(thenable);});

Ist ungefähr äquivalent zu:

new Promise((resolve, reject) => {  try {    thenable.then(      (value) => resolve(value),      (reason) => reject(reason),    );  } catch (e) {    reject(e);  }});

Außer dass im Fall vonresolve(thenable):

1. resolve wird synchron aufgerufen, so dass das erneute Aufrufen vonresolve oderreject keine Wirkung hat, selbst wenn die überanotherPromise.then() angehängten Handler noch nicht aufgerufen werden.
2. Diethen-Methode wird asynchron aufgerufen, so dass das Promise niemals sofort aufgelöst wird, wenn ein thenable übergeben wird.

Daresolve erneut mit dem aufgerufen wird, wasthenable.then() ihm alsvalue übergibt, ist die Rückruffunktion in der Lage, verschachtelte thenables zu glätten, bei denen ein thenable seinenonFulfilled-Handler mit einem anderen thenable aufruft. Der Effekt ist, dass der Erfüllungs-Handler eines realen Promises niemals ein thenable als seinen Erfüllungswert erhält.

Beispiele

Eine Callback-basierte API in eine Promise-basierte umwandeln

Um einer Funktion Promise-Funktionalität bereitzustellen, lassen Sie sie ein Promise zurückgeben, indem Sie dieresolve- undreject-Funktionen zur richtigen Zeit aufrufen.

function myAsyncFunction(url) {  return new Promise((resolve, reject) => {    const xhr = new XMLHttpRequest();    xhr.open("GET", url);    xhr.onload = () => resolve(xhr.responseText);    xhr.onerror = () => reject(xhr.statusText);    xhr.send();  });}

Auswirkung des Aufrufs von resolveFunc

Durch den Aufruf vonresolveFunc wird das Promise aufgelöst, so dass weitere Aufrufe vonresolveFunc oderrejectFunc keine Wirkung haben. Das Promise kann jedoch in einem der folgenden Zustände sein: schwebend, erfüllt oder abgelehnt.

DiesespendingResolved-Promise wird zu dem Zeitpunkt, an dem es erstellt wird, aufgelöst, da es bereits daran "gekoppelt" ist, den eventualen Zustand des inneren Promises zu übernehmen, und der spätere Aufruf vonresolveOuter oderrejectOuter oder das Werfen eines Fehlers im Executor hat keinen Einfluss auf seinen eventualen Zustand. Das innere Promise ist jedoch noch schwebend, bis 100ms später, so dass das äußere Promise ebenfalls schwebend ist:

const pendingResolved = new Promise((resolveOuter, rejectOuter) => {  resolveOuter(    new Promise((resolveInner) => {      setTimeout(() => {        resolveInner("inner");      }, 100);    }),  );});

DiesesfulfilledResolved-Promise wird in dem Moment erfüllt, in dem es aufgelöst wird, da es mit einem nicht-thenable Wert aufgelöst wurde. Wenn es erstellt wird, ist es jedoch unaufgelöst, da wederresolve nochreject bereits aufgerufen wurden. Ein unaufgelöstes Promise ist zwangsläufig schwebend:

const fulfilledResolved = new Promise((resolve, reject) => {  setTimeout(() => {    resolve("outer");  }, 100);});

Durch den Aufruf vonrejectFunc wird das Promise offensichtlich abgelehnt. Es gibt jedoch auch zwei Möglichkeiten, das Promise sofort abzulehnen, selbst wenn derresolveFunc-Rückruf aufgerufen wird.

// 1. Resolving with the promise itselfconst rejectedResolved1 = new Promise((resolve) => {  // Note: resolve has to be called asynchronously,  // so that the rejectedResolved1 variable is initialized  setTimeout(() => resolve(rejectedResolved1)); // TypeError: Chaining cycle detected for promise #<Promise>});// 2. Resolving with an object which throws when accessing the `then` propertyconst rejectedResolved2 = new Promise((resolve) => {  resolve({    get then() {      throw new Error("Can't get then property");    },  });});

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Polyfill vonPromise incore-js
• Verwendung von Promises Leitfaden
• Promise.withResolvers()