Node.js Promise

Promise ist eines der Kernkonzepte für den Umgang mit asynchronen Operationen in Node.js.

Promise bietet eine elegantere Möglichkeit, asynchronen Code zu verwalten, und vermeidet das traditionelle Problem der Callback-Hölle.

Dieser Artikel beschreibt ausführlich das Konzept, die Verwendung und gängige Muster von Promise.

Was ist Promise?

Ein Promise ist ein Objekt, das den eventuellen Abschluss oder das Scheitern einer asynchronen Operation darstellt. Es hat drei Zustände:

  1. Pending (wartend): Anfangszustand, weder erfolgreich noch fehlgeschlagen
  2. Fulfilled (erfolgreich): Die Operation wurde erfolgreich abgeschlossen
  3. Rejected (fehlgeschlagen): Die Operation ist fehlgeschlagen

Sobald sich der Zustand eines Promise ändert (von pending zu fulfilled oder rejected), ändert er sich nicht mehr.

Ein Promise erstellen

In Node.js können Sie denPromiseKonstruktor verwenden, um ein neues Promise-Objekt zu erstellen:

Beispiel

const myPromise = new Promise((resolve, reject) => {
  // Asynchrone Operation
  const success = true; // Angenommen, dies ist das Ergebnis der asynchronen Operation
 
  if (success) {
    resolve('Operation succeeded!'); // Zustand wird erfüllt
  } else {
    reject('Operation failed!'); // Zustand wird abgelehnt
  }
});

Promise verwenden

Promise bietet die.then()und.catch()Methode zur Behandlung von Erfolgs- und Fehlerfällen:

Beispiel

myPromise
  .then((result) => {
    console.log(result); // Ausgabe: "Operation succeeded!"
  })
  .catch((error) => {
    console.error(error); // Ausgabe: "Operation failed!"
  });

Promise-Verkettung

Die Stärke von Promise liegt in seiner Fähigkeit, mehrere asynchrone Operationen zu verketten:

Beispiel

function asyncOperation1() {
  return new Promise((resolve) => {
    setTimeout(() => resolve('Erster Schritt abgeschlossen'), 1000);
  });
}

function asyncOperation2(data) {
  return new Promise((resolve) => {
    setTimeout(() => resolve(`${data},Zweiter Schritt abgeschlossen`), 1000);
  });
}

asyncOperation1()
  .then((result) => asyncOperation2(result))
  .then((finalResult) => {
    console.log(finalResult); // Ausgabe: "Erster Schritt abgeschlossen, Zweiter Schritt abgeschlossen"
  })
  .catch((error) => {
    console.error('Fehler in der Kette:', error);
  });

Statische Methoden von Promise

Promise bietet einige nützliche statische Methoden:

Promise.all()

Wartet darauf, dass alle Promises abgeschlossen werden oder ein beliebiges Promise fehlschlägt:

Beispiel

const promise1 = Promise.resolve('first');
const promise2 = Promise.resolve('second');

Promise.all([promise1, promise2])
  .then((results) => {
    console.log(results); // Ausgabe: ['first', 'second']
  });

Promise.race()

Gibt das Promise zurück, das zuerst abgeschlossen wird (erfüllt oder abgelehnt):

Beispiel

const promise1 = new Promise((resolve) => setTimeout(resolve, 500, 'first'));
const promise2 = new Promise((resolve) => setTimeout(resolve, 100, 'second'));

Promise.race([promise1, promise2])
  .then((result) => {
    console.log(result); // Ausgabe: "second"
  });

Fehlerbehandlung

Die Promise-Fehlerbehandlung kann erfolgen durch.catch()oder.then()den zweiten Parameter von .then:

Beispiel

someAsyncFunction()
  .dann(
    (result) => { /* Erfolg behandeln */ },
    (error) => { /* Fehler behandeln */ }
  );

// Oder
someAsyncFunction()
  .then((result) => { /* Erfolg behandeln */ })
  .catch((error) => { /* Alle Fehler behandeln */ });

async/await-Syntax

ES2017 führte die async/await-Syntax ein, wodurch die Verwendung von Promise intuitiver wird:

Beispiel

async function runOperations() {
  try {
    const result1 = await asyncOperation1();
    const result2 = await asyncOperation2(result1);
    console.log(result2);
  } catch (error) {
    console.error(error);
  }
}

runOperations();

Best Practices

  1. Behandle Fehler immer: Ignoriere sie nicht.catch()oder try-catch
  2. Vermeide Verschachtelung: Verwende Verkettung oder async/await, um den Code flach zu halten
  3. Benenne Promises: Gib Promise-Variablen aussagekräftige Namen
  4. Promises zurückgeben: Gib Promises aus Funktionen zurück, um Verkettung zu ermöglichen
Andere Erweiterungen