Fehlerbehandlung in JavaScript

Dieser Artikel erklärt die Fehlerbehandlung in JavaScript.

YouTube Video

Fehlerbehandlung in JavaScript

Die Fehlerbehandlung in JavaScript ist eine wichtige Funktion, um Fehler zu erkennen und angemessen zu behandeln, wenn ein Programm auf unerwartete Probleme stößt. Es ist üblich, die Syntax try...catch zu verwenden, um Fehler abzufangen und zu behandeln. Zusätzlich kann beim Arbeiten mit Promises oder asynchronen Operationen die Fehlerbehandlung auch mit async/await oder Promise.prototype.catch durchgeführt werden.

try...catch-Syntax

try...catch wird verwendet, um Fehler abzufangen und zu behandeln, wenn sie innerhalb eines Codeblocks auftreten.

 1try {
 2    // Code that may throw an error
 3    let result = riskyFunction();
 4    console.log(result);
 5} catch (error) {
 6    // Catch and handle the error
 7    console.error("An error occurred:", error.message);
 8} finally {
 9    // Code that will always execute
10    console.log("Error handling has completed.");
11}

• Wenn ein Fehler innerhalb eines try-Blocks auftritt, wird die Programmausführung unterbrochen, und der catch-Block wird ausgeführt.
• Der finally-Block wird immer ausgeführt, unabhängig davon, ob ein Fehler auftritt oder nicht. Er ist nützlich, um Ressourcen freizugeben und abschließende Verarbeitungen durchzuführen, unter anderem.

Fehler auslösen (throw)

In JavaScript können Sie mit dem Schlüsselwort throw explizit einen Fehler auslösen. Es wird verwendet, um benutzerdefinierte Fehlermeldungen oder benutzerdefinierte Fehler auszulösen.

 1function checkAge(age) {
 2    if (age < 18) {
 3        throw new Error("You are under 18 years old.");
 4    }
 5    return "Age verification completed.";
 6}
 7
 8try {
 9    let result = checkAge(15);
10    console.log(result);
11} catch (error) {
12    console.error(error.message);  // Displays "You are under 18 years old."
13}

Fehlerbehandlung bei asynchronen Operationen (Promise und async/await)

Bei der Durchführung von asynchronen Operationen unterscheidet sich die Fehlerbehandlung etwas. Beim Verwenden von Promises werden Fehler mit der catch-Methode abgefangen.

1let promise = new Promise((resolve, reject) => {
2    // Asynchronous operation
3    setTimeout(() => reject(new Error("An issue has occurred!")), 1000);
4});
5
6promise
7    .then(result => console.log(result))
8    .catch(error => console.error(error.message));  // Displays "An issue has occurred!"

Bei der Durchführung von asynchronen Operationen mit async/await können Fehler mit try...catch behandelt werden.

 1async function fetchData() {
 2    try {
 3        let response = await fetch('https://api.example.com/data');
 4        let data = await response.json();
 5        console.log(data);
 6    } catch (error) {
 7        console.error("An error occurred while fetching data:", error.message);
 8    }
 9}
10
11fetchData();

Zusammenfassung

• Synchron auftretende Fehler können mit der try...catch-Syntax abgefangen werden.
• Sie können eigene Fehler mit throw auslösen.
• Fehler bei asynchronen Operationen können mit der catch-Methode von Promise oder mit async/await und try...catch behandelt werden.

Durch die Nutzung dieser Methoden können Sie sicherstellen, dass Ihr Programm auch bei Auftreten von Fehlern korrekt funktioniert.

Error

Die Error-Klasse wird für die Fehlerbehandlung verwendet. Sie ermöglicht es, Fehler zu erzeugen und Fehlermeldungen sowie Stack-Traces bereitzustellen.

1try {
2    throw new Error("Something went wrong");
3} catch (e) {
4    console.log(e.message); // Something went wrong
5}

Grundlegende Verwendung

Ein Error-Objekt kann explizit erstellt werden, wenn ein Fehler auftritt. Sie erstellen eine Instanz mit new Error() und übergeben eine Fehlermeldung.

1const error = new Error("Something went wrong");
2console.log(error.message);  // "Something went wrong"
3console.log(error.name);     // "Error"
4console.log(error.stack);    // Stack trace (information about where the error occurred)

Fehler mit throw auslösen

In JavaScript können Sie einen Fehler mit dem throw-Schlüsselwort auslösen. Dies wird verwendet, um die Verarbeitung in bestimmten Situationen zu unterbrechen und die Kontrolle an einen Fehlerbehandler zu übergeben.

1function doSomething() {
2    throw new Error("This function is not yet implemented");
3}
4
5try {
6    doSomething();
7} catch (e) {
8    console.error(e.message);  // "This function is not yet implemented"
9}

Mit throw ausgelöste Fehler können mit der try...catch-Syntax abgefangen werden.

Erstellen von benutzerdefinierten Fehlern

In JavaScript können Sie eigene benutzerdefinierte Fehler erstellen, indem Sie die Error-Klasse erweitern. Dies ermöglicht es Ihnen, Fehler zu erstellen, die auf spezifische Situationen zugeschnitten sind.

 1class CustomError extends Error {
 2    constructor(message) {
 3        super(message);  // Call the parent class constructor
 4        this.name = "CustomError";  // Set the error name
 5    }
 6}
 7
 8try {
 9    throw new CustomError("A custom error has occurred");
10} catch (e) {
11    console.error(e.name);    // "CustomError"
12    console.error(e.message); // "A custom error has occurred"
13}

Eingebaute Fehlerklassen

JavaScript verfügt über mehrere eingebaute Fehlerklassen, die die Error-Klasse erweitern. Diese werden verwendet, um spezifische Fehler darzustellen.

• ReferenceError: Tritt auf, wenn Sie auf eine nicht existierende Variable verweisen.
• TypeError: Tritt auf, wenn der Typ eines Wertes vom erwarteten Typ abweicht.
• RangeError: Tritt auf, wenn eine Zahl außerhalb des zulässigen Bereichs liegt.
• SyntaxError: Tritt auf, wenn nicht syntaktisch korrekter Code ausgeführt wird.
• EvalError: Fehler im Zusammenhang mit der Verwendung der eval()-Funktion. Es wird heutzutage selten verwendet.
• URIError: Tritt auf, wenn eine ungültige URI (Kodierungs- oder Dekodierungsfehler) verwendet wird.

Beispiel: ReferenceError

Hier ist ein Beispiel für einen ReferenceError.

1try {
2    console.log(undefinedVariable);  // Undefined variable
3} catch (e) {
4    console.error(e.name);    // "ReferenceError"
5    console.error(e.message); // "undefinedVariable is not defined"
6}

Beispiel: TypeError

Hier ist ein Beispiel für einen TypeError.

1try {
2    null.f();  // Attempting to call a function on null
3} catch (e) {
4    console.error(e.name);    // "TypeError"
5    console.error(e.message); // "Cannot read properties of null (reading 'f')"
6}

finally-Block

Verwenden Sie im try...catch-Syntax den finally-Block für Operationen, die Sie unabhängig vom Auftreten eines Fehlers ausführen möchten.

1try {
2    throw new Error("An issue has occurred");
3} catch (e) {
4    console.error(e.message);  // "An issue has occurred"
5} finally {
6    console.log("Performing cleanup");
7}

In diesem Beispiel werden die Operationen im finally-Block ausgeführt, selbst wenn ein Fehler auftritt.

Eigenschaften des Error-Objekts

Das Error-Objekt verfügt über die folgenden Eigenschaften.

• message: Dies ist die Fehlermeldung.
• name: Der Name des Fehlers, der standardmäßig auf "Error" gesetzt ist.
• stack: Eine Stack-Trace, die den Ort des Fehlers enthält, nützlich für die Fehlersuche.

Vorteile der Ausnahmebehandlung

Durch die korrekte Implementierung der Fehlerbehandlung können Sie verhindern, dass die Anwendung bei unerwartetem Verhalten abstürzt. Durch die angemessene Verwendung der try...catch-Syntax und Fehlerobjekte können Sie robusteren Code schreiben.

 1function divide(a, b) {
 2    if (b === 0) {
 3        throw new Error("Cannot divide by zero");
 4    }
 5    return a / b;
 6}
 7
 8try {
 9    console.log(divide(4, 0));  // An error will occur
10} catch (e) {
11    console.error(e.message);   // "Cannot divide by zero"
12}

Zusammenfassung

• Die Error-Klasse wird verwendet, um eine Fehlerursache darzustellen und die Fehlerbehandlung durchzuführen.
• Verwenden Sie die try...catch...finally-Syntax, um Fehler zu behandeln und unerwartete Anwendungsabbrüche zu vermeiden.
• Es ist auch möglich, die Error-Klasse zu erweitern, um benutzerdefinierte Fehler zu erstellen.
• Sie können verschiedene Arten von Fehlern mithilfe von eingebauten Fehlerklassen wie TypeError und ReferenceError behandeln.

Sie können den obigen Artikel mit Visual Studio Code auf unserem YouTube-Kanal verfolgen. Bitte schauen Sie sich auch den YouTube-Kanal an.

YouTube Video