JavaScript -Versprechen verstehen

Versprechen sind ein leistungsstarkes Merkmal in JavaScript, das den Umgang mit asynchronen Operationen vereinfacht. Sie bieten einen saubereren und intuitiveren Weg, um mit asynchronen Code zu arbeiten, um Probleme wie "Callback Hell" zu vermeiden.

Was ist ein Versprechen?

a versprachen ist ein Objekt, das den eventuellen Abschluss (oder das Misserfolg) einer asynchronen Operation und ihren resultierenden Wert darstellt. Sie ermöglicht es Ihnen, überschaubarere asynchronen Code zu schreiben, indem Sie Operationen und Fehler effektiv behandeln.

Staaten eines Versprechens

Ein Versprechen hat drei Staaten:

• anhängig : Der Anfangszustand, weder erfüllt noch abgelehnt.
• erfüllt : Die Operation erfolgreich abgeschlossen, und das Versprechen hat einen daraus resultierenden Wert.
• abgelehnt : Die Operation ist fehlgeschlagen, und das Versprechen hat einen Grund für das Scheitern (normalerweise ein Fehler).

Beispiel:

const promise = new Promise((resolve, reject) => {
  let success = true; // Change to false to simulate rejection

  if (success) {
    resolve("Operation was successful!");
  } else {
    reject("Operation failed.");
  }
});

promise
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

Versprechen Methoden

1. dann ()

• verwendet, um die Erfüllung eines Versprechens zu bewältigen.
• gibt ein anderes Versprechen zurück und ermöglicht die Verkettung.

promise
  .then((result) => {
    console.log(result);
    return "Next Step";
  })
  .then((nextResult) => console.log(nextResult));

2. catch ()

• wird verwendet, um Versprechenablehnungen zu behandeln.

promise.catch((error) => console.error(error));

3.. Schließlich ()

• verwendet, um ein Stück Code unabhängig vom Ergebnis des Versprechens auszuführen.

promise.finally(() => console.log("Cleanup actions."));

4. Versprechen.All ()

• beschließt, wenn alle Versprechen in einem Array aufgelöst werden.
• lehnt sofort ab, wenn ein Versprechen abgelehnt wird.

const promise1 = Promise.resolve(10);
const promise2 = Promise.resolve(20);

Promise.all([promise1, promise2]).then((results) => console.log(results));

5. Versprechen.Allsettled ()

• wartet auf alle Versprechen, sich niederzulassen (entweder erfüllt oder abgelehnt).

const promise1 = Promise.resolve("Success");
const promise2 = Promise.reject("Error");

Promise.allSettled([promise1, promise2]).then((results) => console.log(results));

6. Versprechen.Race ()

• beschließt oder lehnt ab, sobald einer der Versprechen auflöst oder ablehnt.

const promise1 = new Promise((resolve) => setTimeout(resolve, 500, "One"));
const promise2 = new Promise((resolve) => setTimeout(resolve, 100, "Two"));

Promise.race([promise1, promise2]).then((result) => console.log(result));

7. Versprechen.anan ()

• beschließt, sobald eines der Versprechen erfüllt wird.
• lehnt ab, ob alle Versprechen abgelehnt werden.

const promise1 = Promise.reject("Error 1");
const promise2 = Promise.resolve("Success");
const promise3 = Promise.reject("Error 2");

Promise.any([promise1, promise2, promise3]).then((result) => console.log(result));

Versprechen versprechen

Das Ketten ermöglicht das Umgang mit mehreren asynchronen Operationen nacheinander.

fetch("https://api.example.com/data")
  .then((response) => response.json())
  .then((data) => {
    console.log(data);
    return fetch("https://api.example.com/other-data");
  })
  .then((otherResponse) => otherResponse.json())
  .then((otherData) => console.log(otherData))
  .catch((error) => console.error("Error:", error));

Fehlerbehandlung in Versprechen

Fehler propagieren durch die Versprechenkette, bis ein Catch () Block gefangen wird.

fetch("https://api.example.com/data")
  .then((response) => {
    if (!response.ok) throw new Error("Network response was not ok");
    return response.json();
  })
  .then((data) => console.log(data))
  .catch((error) => console.error("Error:", error));

Real-Life-Anwendungsfallbeispiel

Sie können hier einen detaillierten realen Anwendungsfall von Versprechen untersuchen:

Abschluss

JavaScript -Versprechen bieten eine robuste Möglichkeit, mit Klarheit und Effizienz mit asynchronen Operationen umzugehen. Durch das Beherrschen von Versprechen können Sie sauberere, wartbarere Code schreiben und Fallstricke wie Callback -Hölle vermeiden. Beginnen Sie mit den oben genannten Methoden und Beispielen, und Sie werden auf dem besten Weg sind, asynchrone JavaScript zu beherrschen!