Fehlerbehandlung in TypeScript

Dieser Artikel erklärt die Fehlerbehandlung in TypeScript.

YouTube Video

Fehlerbehandlung in TypeScript

Die Fehlerbehandlung in TypeScript erfolgt grundsätzlich mit der try...catch-Struktur, genau wie in JavaScript. In TypeScript ist es möglich, die Fehlerinhalte dank Typrückschlüssen klarer zu verwalten. Dies ermöglicht eine präzisere und lesbarere Fehlerbehandlung.

try...catch-Syntax

Die grundlegende Syntax für die Fehlerbehandlung ist wie folgt:.

 1try {
 2    // Code that may throw an error
 3    throw new Error("Something went wrong!");
 4} catch (error) {
 5    // Catch and handle the error
 6    console.error("Error:", error);
 7} finally {
 8    // Code that runs regardless of whether an error occurred
 9    console.log("Finally block executed.");
10}

Typsichere Fehlerbehandlung

In TypeScript werden Fehler, die innerhalb eines catch-Blocks abgefangen werden, als any-Typ behandelt. Es wird jedoch empfohlen, den entsprechenden Typ anzugeben, um eine sicherere Fehlerbehandlung zu gewährleisten. Beispielsweise können Sie einen benutzerdefinierten Fehler-Typ wie folgt definieren und verwenden:.

 1class CustomError extends Error {
 2    constructor(message: string, public errorCode: number) {
 3        super(message);
 4        this.name = "CustomError";
 5    }
 6}
 7
 8try {
 9    throw new CustomError("Invalid operation", 400);
10} catch (error) {
11    if (error instanceof CustomError) {
12        console.error(`Error: ${error.message}, Code: ${error.errorCode}`);
13    } else {
14        console.error("Unknown error occurred");
15    }
16}

In diesem Beispiel wird eine Klasse namens CustomError erstellt und ein Fehler mit benutzerdefinierten Eigenschaften wie errorCode ausgelöst. Im catch-Block wird instanceof verwendet, um den Fehler-Typ zu bestimmen und eine entsprechende Behandlung durchzuführen.

Asynchrone Fehlerbehandlung

In TypeScript wird try...catch auch verwendet, um Fehler beim Einsatz asynchroner Funktionen zu behandeln.

 1async function fetchData() {
 2    try {
 3        const response = await fetch("https://api.example.com/data");
 4        if (!response.ok) {
 5            throw new Error(`HTTP error! status: ${response.status}`);
 6        }
 7        const data = await response.json();
 8        console.log(data);
 9    } catch (error) {
10        console.error("Failed to fetch data:", error);
11    }
12}
13
14fetchData();

In diesem Beispiel werden Daten mit fetch abgerufen, und response.ok wird überprüft, um einen Fehler auszulösen, wenn der Statuscode nicht in Ordnung ist. Der Fehler wird in catch abgefangen, und das entsprechende Protokoll wird ausgegeben.

Zusammenfassung

In TypeScript macht die Verwendung von Typen zur Klärung von Fehlerinhalten die Fehlerbehandlung sicherer und lesbarer. Bei der Fehlerbehandlung ist es wichtig, zu klären, welche Arten von Fehlern auftreten können, und sie entsprechend zu behandeln.

Fehler

Die Error-Klasse in TypeScript erweitert die Error-Klasse in JavaScript und ist ein grundlegendes Objekt zur Darstellung von Fehlern. Mit der Error-Klasse können Sie ein Objekt erstellen, das eine Fehlermeldung enthält, und eine Fehlerbehandlung durchführen.

Grundlagen der Error-Klasse

Die Error-Klasse wird wie folgt verwendet.

1const error = new Error("Something went wrong!");
2console.log(error.message); // "Something went wrong!"
3console.log(error.name);    // "Error"

Eigenschaften

Die Klasse Error verfügt über die folgenden Eigenschaften:.

• message Ein String, der die Fehlermeldung darstellt.
• name Der Name des Fehlers. Standardmäßig ist es "Error", aber es kann durch Erstellen einer benutzerdefinierten Fehlerklasse geändert werden.
• stack Stack-Trace-Informationen, die zum Debuggen verwendet werden. Eine Zeichenkette, die angibt, welcher Code den Fehler verursacht hat, als er auftrat.

Benutzerdefinierte Fehlerklasse

Es ist auch möglich, die Error-Klasse zu erweitern und eigene Fehlerklassen zu erstellen. Dies ist in Situationen nützlich, in denen eine spezifische Fehlerbehandlung erforderlich ist. Zum Beispiel ist es effektiv, wenn Sie verschiedene Fehlertypen wie HTTP-Anfragefehler oder Datenbankfehler behandeln möchten.

Beispiel für das Erstellen eines benutzerdefinierten Fehlers

 1class CustomError extends Error {
 2    constructor(message: string, public errorCode: number) {
 3        super(message); // Call the constructor of the parent class 'Error'
 4        this.name = "CustomError"; // Set the name of the error
 5    }
 6}
 7
 8const customError = new CustomError("Invalid operation", 400);
 9console.log(customError.message);   // "Invalid operation"
10console.log(customError.name);      // "CustomError"
11console.log(customError.errorCode); // 400

• Durch das Erstellen einer CustomError-Klasse und das Hinzufügen von Informationen wie Fehlercodes können Sie umfassendere Informationen über Fehler verwalten.

Vererbung der Error-Klasse

In TypeScript gibt es einige Punkte zu beachten, wenn Sie eine benutzerdefinierte Fehlerklasse durch Erweitern der Error-Klasse erstellen.

1. Aufruf von super() Im Konstruktor einer benutzerdefinierten Fehlerklasse muss super() aufgerufen werden, um den Konstruktor der Error-Klasse zu verwenden. Dies stellt sicher, dass die Eigenschaften message und stack korrekt initialisiert werden.

2. Eigenschaften hinzufügen Wenn Sie zusätzliche Informationen zum Fehlerobjekt hinzufügen möchten, definieren Sie neue Eigenschaften innerhalb der Klasse. Zum Beispiel wird in der obigen CustomError-Klasse eine errorCode-Eigenschaft hinzugefügt.

Auslösen und Abfangen von Fehlern

Sie können Fehler behandeln, indem Sie Fehler mittels der Error-Klasse oder einer benutzerdefinierten Fehlerklasse auslösen und anschließend abfangen.

 1function riskyOperation() {
 2    throw new Error("Something went wrong during the operation");
 3}
 4
 5try {
 6    riskyOperation();
 7} catch (error) {
 8    if (error instanceof Error) {
 9        console.error(error.message);  // "Something went wrong during the operation"
10        console.error(error.name);     // "Error"
11    }
12}

Auch im Fall von benutzerdefinierten Fehlern verwenden Sie instanceof, um spezifische Fehler zu identifizieren und sie entsprechend zu behandeln.

 1class CustomError extends Error {
 2    constructor(message: string, public errorCode: number) {
 3        super(message);
 4        this.name = "CustomError";
 5    }
 6}
 7
 8try {
 9    throw new CustomError("Database connection failed", 500);
10} catch (error) {
11    if (error instanceof CustomError) {
12        console.error(`Error: ${error.message}, Code: ${error.errorCode}`);
13    }
14}

Zusammenfassung

Die Error-Klasse in TypeScript ist eine grundlegende Klasse zur Durchführung der Standard-Fehlerbehandlung. Darüber hinaus wird durch das Erweitern der Error-Klasse zur Erstellung benutzerdefinierter Fehler eine flexible Fehlerbehandlung basierend auf Fehlertypen und zusätzlichen Informationen möglich.

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