Obsługa błędów w TypeScript

Ten artykuł wyjaśnia obsługę błędów w TypeScript.

YouTube Video

Obsługa błędów w TypeScript

Obsługa błędów w TypeScript odbywa się zasadniczo za pomocą konstrukcji try...catch, tak jak w JavaScript. W TypeScript możliwe jest wyraźniejsze zarządzanie treścią błędów dzięki wnioskowaniu typów. To pozwala na bardziej precyzyjną i czytelną obsługę błędów.

Składnia try...catch

Podstawowa składnia obsługi błędów wygląda następująco:.

 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}

Typowo bezpieczna obsługa błędów

W TypeScript błędy przechwycone w bloku catch są traktowane jako typ any, ale zaleca się określenie odpowiedniego typu dla bezpieczniejszej obsługi błędów. Na przykład można zdefiniować i używać niestandardowego typu błędu w następujący sposób:.

 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}

W tym przykładzie tworzona jest klasa o nazwie CustomError, a następnie wyrzucany jest błąd z własnymi właściwościami, takimi jak errorCode. W bloku catch użyj instanceof, aby określić typ błędu i podjąć odpowiednie działania.

Asynchroniczna obsługa błędów

W TypeScript konstrukcja try...catch jest również używana do obsługi błędów podczas korzystania z funkcji asynchronicznych.

 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();

W tym przykładzie dane są pobierane za pomocą fetch, a response.ok jest sprawdzane, aby zgłosić błąd, jeśli kod statusu nie jest OK. Błąd jest przechwytywany w catch, a odpowiedni log jest wyświetlany.

Podsumowanie

W TypeScript używanie typów do wyjaśnienia treści błędów sprawia, że obsługa błędów jest bezpieczniejsza i bardziej czytelna. Podczas obsługi błędów ważne jest, aby wyjaśnić, jakie typy błędów mogą wystąpić, i odpowiednio je obsłużyć.

Błąd

Klasa Error w TypeScript rozszerza klasę Error w JavaScript i jest podstawowym obiektem do reprezentowania błędów. Korzystając z klasy Error, można utworzyć obiekt zawierający komunikat o błędzie i przeprowadzić obsługę błędów.

Podstawy klasy Error

Klasa Error jest używana w następujący sposób.

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

Właściwości

Klasa Error posiada następujące właściwości:.

• message Ciąg znaków reprezentujący komunikat błędu.
• name Nazwa błędu. Domyślnie jest to "Error", ale można to zmienić, tworząc własną klasę błędu.
• stack Informacje o śladzie stosu wykorzystywane podczas debugowania. Ciąg znaków wskazujący, który kod spowodował błąd w momencie jego wystąpienia.

Własna Klasa Błędów

Można również rozszerzyć klasę Error i stworzyć własne klasy błędów. Jest to przydatne w sytuacjach, gdy wymagane jest określone zarządzanie błędami. Na przykład jest to skuteczne, gdy chcesz obsługiwać różne typy błędów, takie jak błędy żądań HTTP lub błędy bazy danych.

Przykład Tworzenia Własnego Błędu

 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

• Tworząc klasę CustomError i dodając informacje takie jak kody błędów, możesz zarządzać bardziej szczegółowymi informacjami o błędach.

Dziedziczenie Klasy Error

W TypeScript, przy tworzeniu własnej klasy błędu poprzez rozszerzenie klasy Error, należy zwrócić uwagę na kilka kwestii.

1. Wywołanie super() W konstruktorze własnej klasy błędu należy wywołać super(), aby wywołać konstruktor klasy Error. Zapewnia to poprawną inicjalizację właściwości message i stack.

2. Dodawanie właściwości Jeśli chcesz dodać do obiektu błędu dodatkowe informacje, zdefiniuj nowe właściwości w klasie. Na przykład w powyższym CustomError została dodana właściwość errorCode.

Rzucanie i Obsługa Błędów

Możesz obsługiwać błędy, wyrzucając je z użyciem klasy Error lub własnej klasy błędów, a następnie je przechwytując.

 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}

W przypadku własnych błędów również używaj instanceof, aby zidentyfikować konkretne błędy i odpowiednio je obsłużyć.

 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}

Podsumowanie

Klasa Error w TypeScript to podstawowa klasa służąca do wykonywania standardowej obsługi błędów. Ponadto, rozszerzając klasę Error, aby tworzyć własne błędy, możliwa staje się elastyczna obsługa błędów w oparciu o ich typy i dodatkowe informacje.

Możesz śledzić ten artykuł, korzystając z Visual Studio Code na naszym kanale YouTube. Proszę również sprawdzić nasz kanał YouTube.

YouTube Video