Pumble in JavaScript

JavaScript-Versprechen verstehen

Promises sind eine leistungsstarke Funktion in JavaScript, die die Handhabung asynchroner Vorgänge vereinfacht. Sie bieten eine sauberere und intuitivere Möglichkeit, mit asynchronem Code zu arbeiten und vermeiden Probleme wie die „Callback-Hölle“.

---

Was ist ein Versprechen?

Ein Promise ist ein Objekt, das den eventuellen Abschluss (oder Misserfolg) einer asynchronen Operation und den daraus resultierenden Wert darstellt. Es ermöglicht Ihnen, besser verwaltbaren asynchronen Code zu schreiben, indem Sie Vorgänge verketten und Fehler effektiv behandeln.

Zustände eines Versprechens

Ein Versprechen hat drei Zustände:

• Ausstehend: Der Ausgangszustand, weder erfüllt noch abgelehnt.
• Erfüllt: Der Vorgang wurde erfolgreich abgeschlossen und das Versprechen hat einen resultierenden Wert.
• Abgelehnt: Der Vorgang ist fehlgeschlagen und das Versprechen hat einen Grund für das Scheitern (normalerweise einen 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));

---

Versprechensmethoden

1. then()

• Wird verwendet, um die Erfüllung eines Versprechens abzuwickeln.
• Gibt ein weiteres 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 zur Bearbeitung von Versprechensablehnungen verwendet.

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

3. endlich()

• Wird verwendet, um einen Codeabschnitt unabhängig vom Ergebnis des Versprechens auszuführen.

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

4. Promise.all()

• Wird aufgelöst, wenn alle Versprechen in einem Array aufgelöst sind.
• 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. Promise.allSettled()

• Warten, bis alle Versprechen erfüllt sind (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. Promise.race()

• Wird gelöst oder abgelehnt, sobald eines der Versprechen gelöst oder abgelehnt wird.

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. Promise.any()

• Wird gelöst, sobald eines der Versprechen erfüllt ist.
• Lehnt ab, wenn 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 verketten

Verkettung ermöglicht die aufeinanderfolgende Verarbeitung mehrerer asynchroner Vorgänge.

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 breiten sich durch die Versprechenskette aus, bis sie von einem Catch()-Block abgefangen werden.

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));

---

Beispiel für einen realen Anwendungsfall

Hier können Sie einen detaillierten Anwendungsfall von Promises aus der Praxis erkunden:

<script></script>

---

Abschluss

JavaScript Promises bieten eine robuste Möglichkeit, asynchrone Vorgänge klar und effizient abzuwickeln. Indem Sie Versprechen beherrschen, können Sie saubereren, wartbareren Code schreiben und Fallstricke wie die Callback-Hölle vermeiden. Beginnen Sie mit dem Üben mit den oben genannten Methoden und Beispielen und Sie sind auf dem besten Weg, asynchrones JavaScript zu beherrschen!

Das obige ist der detaillierte Inhalt vonPumble in JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!