Auf Wiedersehen Ausnahmen! Beherrschen der Fehlerbehandlung in JavaScript mit dem Ergebnismuster

Das Ergebnismuster ist ein funktionaler Programmieransatz, der in vielen Programmiersprachen wie Rust, Go, C# (und anderen Sprachen) verwendet wird, um Fehler zu behandeln, ohne auf Try-Catch-Blöcke angewiesen zu sein. Dabei geht es darum, das Ergebnis einer Operation als Objekt darzustellen, das explizit Erfolg oder Misserfolg anzeigt. Dieses Muster ist besonders nützlich bei der asynchronen Programmierung.

Was ist das Ergebnismuster?

Das Ergebnismuster stellt das Ergebnis einer Operation unter Verwendung zweier expliziter Zustände dar:

• Erfolg (Ok): Enthält den Erfolgswert.
• Fehler (Err): Enthält den Fehler- oder Fehlergrund

So implementieren Sie das Ergebnismuster

Lasst uns ein Result Utility-Objekt erstellen

const Result = {
  Ok: (value) => ({ isOk: true, value }),
  Err: (error) => ({ isOk: false, error }),
};

Lassen Sie uns dieses Ergebnismuster in einer asynchronen Funktion verwenden

const fetchData = async (url) => {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      return Result.Err(`HTTP error: ${response.status}`);
    }
    const data = await response.json();
    return Result.Ok(data);
  } catch (err) {
    return Result.Err(err.message);
  }
};

const main = async () => {
  const result = await fetchData("https://jsonplaceholder.typicode.com/posts");
  if (result.isOk) {
    console.log("Success:", result.value);
  } else {
    console.error("Error:", result.error);
  }
};

main();

Vorteile des Ergebnismusters

1. Verbesserte Lesbarkeit: Vermeidet verschachtelte Try-Catch-Blöcke
Problem mit Try-Catch:
Die Verwendung von Try-Catch zur Fehlerbehandlung kann bei der Verarbeitung mehrerer Vorgänge zu tief verschachteltem Code führen. Dadurch ist der Code schwieriger zu lesen und zu warten.

Der Hauptvorteil des Ergebnismusters besteht darin, dass das Ergebnismuster Fehler als Teil des Rückgabewerts kapselt, sodass keine verschachtelten Try-Catch-Blöcke erforderlich sind. Die Fehlerbehandlungslogik wird sauberer und strukturierter.

Sehen wir uns ein Beispiel einer verschachtelten Try-Catch-Ausnahme an

const process = async (data) =>{
    // YOUR LOGIC TO PROCESS THE DATA
    return result
}

const processData = async () => {
    try {
      const response = await fetch("https://jsonplaceholder.typicode.com/posts");
      const data = await response.json();
      try {
        const processedData = process(data);
        return processedData;
      } catch (processError) {
        console.error("Error processing data:", processError);
      }
    } catch (fetchError) {
      console.error("Error fetching data:", fetchError);
    }
};

Jetzt können wir die gleiche Datenabruflogik mithilfe des Ergebnismusters implementieren

const process = async (data) =>{
    // YOUR LOGIC TO PROCESS THE DATA
    return result
}

const processData = async () => {
  const fetchResult = await fetchData("https://jsonplaceholder.typicode.com/posts");
  if (!fetchResult.isOk) return fetchResult;

  const processResult = process(fetchResult.value);
  return processResult;
};

2. Deutlichkeit: Kommuniziert deutlich die Möglichkeit eines Scheiterns
Problem mit der impliziten Fehlerbehandlung:
JavaScript-Funktionen können implizit Fehler auslösen, sodass unklar ist, ob eine Funktion möglicherweise fehlschlägt, wenn sie nicht explizit dokumentiert wird. Dies kann zu unerwarteten Laufzeitfehlern führen.

Wie das Ergebnismuster hilft:
Das Ergebnismuster gibt explizit „OK“ oder „Err“ zurück und signalisiert damit, ob ein Vorgang erfolgreich war oder fehlgeschlagen ist. Dadurch wird das Verhalten der Funktion vorhersehbar und leichter nachvollziehbar.

Beispiel für die implizite Fehlerbehandlung

const processUserInput = (input) => {
  if (!input || input.trim() === "") {
    throw new Error("Input cannot be empty");
  }
  return `Processed: ${input}`;
};

Beispiel für die explizite Fehlerbehandlung mit Ergebnismuster

const processUserInput = (input) => {
  if (!input || input.trim() === "") {
    return Result.Err("Input cannot be empty");
  }
  return Result.Ok(`Processed: ${input}`);
};

const userInput = "  ";
const result = processUserInput(userInput);

if (result.isOk) {
  console.log("Success:", result.value);
} else {
  console.error("Failure:", result.error);
}

3. Zusammensetzbarkeit: Einfachere Verkettung von Vorgängen
Problem mit Try-Catch:
Bei der Verkettung mehrerer Vorgänge kann eine Ausnahme den gesamten Ablauf unterbrechen. Die Behandlung dieser Ausnahmen mit Try-Catch fügt erhebliche Boilerplate hinzu.

Wie das Ergebnismuster hilft:
Das Ergebnismuster vereinfacht die Komposition, indem es Ok-Werte weiterleitet und die Ausführung beim ersten Err stoppt. Dies gewährleistet einen sauberen und vorhersehbaren Ablauf der Abläufe.

Beispiel für ein Muster ohne Ergebnis

const Result = {
  Ok: (value) => ({ isOk: true, value }),
  Err: (error) => ({ isOk: false, error }),
};

Beispiel mit Ergebnismuster

const fetchData = async (url) => {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      return Result.Err(`HTTP error: ${response.status}`);
    }
    const data = await response.json();
    return Result.Ok(data);
  } catch (err) {
    return Result.Err(err.message);
  }
};

const main = async () => {
  const result = await fetchData("https://jsonplaceholder.typicode.com/posts");
  if (result.isOk) {
    console.log("Success:", result.value);
  } else {
    console.error("Error:", result.error);
  }
};

main();

Abschluss

Das Ergebnismuster bietet eine leistungsstarke und elegante Alternative zu Try-Catch für die Fehlerbehandlung in JavaScript. Durch die verbesserte Lesbarkeit, explizite Fehlerbehandlung und Zusammensetzbarkeit wird die Robustheit und Vorhersagbarkeit asynchroner Arbeitsabläufe verbessert.

Wenn Sie mit komplexer Logik oder mehreren asynchronen Vorgängen arbeiten, sollten Sie die Verwendung des Ergebnismusters in Betracht ziehen, um Ihren Code sauberer und wartbarer zu machen.

Sie können gerne Ihre Meinung zu diesem Muster abgeben, wir entschuldigen uns für etwaige Tippfehler.

Das obige ist der detaillierte Inhalt vonAuf Wiedersehen Ausnahmen! Beherrschen der Fehlerbehandlung in JavaScript mit dem Ergebnismuster. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!