Wie kann man einen Fehler (Ablehnung) eines Promises…

Beim Verwenden von await mit einer Versprechen können Fehler (Ablehnungen) auf verschiedene Weisen behandelt werden:

Konstruktion try...catch: Die gebräuchlichste und empfohlene Methode. Ermöglicht es, Fehler elegant abzufangen, die bei der Auflösung (resolve) oder Ablehnung (reject) des Versprechens auftreten.

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error(`HTTP-Fehler! Status: ${response.status}`);
    }
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Fehler beim Abrufen der Daten:', error);
    // Zusätzliche Fehlerbehandlung oder Benutzerbenachrichtigung
  }
}

fetchData();

Methode .catch() nach await: Weniger bevorzugt, aber möglich. Der Fehler wird im Callback .catch() behandelt, wenn das Versprechen abgelehnt wird.

async function fetchData() {
  const response = await fetch('https://api.example.com/data')
    .catch(error => {
      console.error('Fehler bei fetch:', error);
      // Fehlerbehandlung für fetch
      throw error; // Fehler für weitere Behandlung weiterwerfen
    });

  if (response && !response.ok) {
       console.error(`HTTP-Fehler! Status: ${response.status}`);
       // HTTP-Fehlerbehandlung
  }

  if (response && response.ok) {
      const data = await response.json()
          .catch(error => {
              console.error('Fehler beim Parsen von JSON:', error);
              // Fehlerbehandlung beim JSON-Parsing
          });
      if (data) {
          console.log(data);
      }
  }
}

fetchData();

Dieser Ansatz kann bei der Behandlung mehrerer potenzieller Fehlerpunkte unübersichtlich werden.

Behandlung mit Fehler-Rückgabewert: Einige Bibliotheken oder eigene Funktionen können ein Tupel [Daten, Fehler] anstelle der Ablehnung des Versprechens zurückgeben.

async function safelyFetchData() {
   const [data, error] = await safePromise(fetch('https://api.example.com/data'));
   if (error) {
      console.error('Allgemeiner Fehler beim Abrufen der Daten:', error);
      return null; // Oder ein anderes Wert, das auf einen Fehler hinweist
   }
   // Es wird angenommen, dass safePromise auch response.ok Fehler behandelt
   console.log(data);
   return data;
}

// Beispiel für eine Implementierung von safePromise (vereinfachte Version)
async function safePromise(promise) {
    try {
        const result = await promise;
         // Hier könnte eine Überprüfung result.ok für fetch erfolgen
         if (result && result.ok !== undefined && !result.ok) {
             throw new Error(`HTTP-Fehler! Status: ${result.status}`);
         }
        // Für fetch könnte es notwendig sein, result.json() zu awaiten
        if (result && typeof result.json === 'function') {
            const jsonData = await result.json();
            return [jsonData, null];
        }
        return [result, null];
    } catch (error) {
        return [null, error];
    }
}

safelyFetchData();

Dieses Muster (oft "error-first callback" oder "Go-Style-Fehlerbehandlung" genannt) ist nützlich, wenn Fehler lokal behandelt werden sollen, ohne die Ausführung der Funktion zu unterbrechen.

Die sauberste und lesbarste Methode ist die Verwendung von try...catch um den Codeblock, der await enthält.

Wie kann man einen Fehler (Ablehnung) eines Promises bei Verwendung von await behandeln?