Heim > Web-Frontend > js-Tutorial > Auf Wiedersehen Ausnahmen! Beherrschen der Fehlerbehandlung in JavaScript mit dem Ergebnismuster

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

DDD
Freigeben: 2024-11-28 22:46:12
Original
591 Leute haben es durchsucht

Goodbye Exceptions! Mastering Error Handling in JavaScript with the Result Pattern

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 }),
};
Nach dem Login kopieren
Nach dem Login kopieren

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();
Nach dem Login kopieren
Nach dem Login kopieren

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);
    }
};
Nach dem Login kopieren

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;
};
Nach dem Login kopieren

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}`;
};
Nach dem Login kopieren

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);
}
Nach dem Login kopieren

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 }),
};
Nach dem Login kopieren
Nach dem Login kopieren

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();
Nach dem Login kopieren
Nach dem Login kopieren

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!

Quelle:dev.to
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage