Gestione degli errori in TypeScript

Questo articolo spiega la gestione degli errori in TypeScript.

YouTube Video

Gestione degli errori in TypeScript

La gestione degli errori in TypeScript viene fondamentalmente eseguita utilizzando la struttura try...catch, proprio come in JavaScript. In TypeScript, è possibile gestire più chiaramente il contenuto degli errori tramite l'inferenza di tipo. Questo consente una gestione degli errori più precisa e leggibile.

Sintassi di try...catch

La sintassi base per la gestione degli errori è la seguente:.

 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}

Gestione degli errori tipicamente sicura

In TypeScript, gli errori catturati all'interno di un blocco catch vengono trattati come tipo any, ma si consiglia di specificare il tipo appropriato per una gestione degli errori più sicura. Ad esempio, è possibile definire e utilizzare un tipo di errore personalizzato come mostrato di seguito:.

 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 questo esempio viene creata una classe chiamata CustomError e viene generato un errore con proprietà personalizzate come errorCode. Nel blocco catch, usa instanceof per determinare il tipo di errore e eseguire la gestione appropriata.

Gestione degli errori asincrona

In TypeScript, try...catch viene usato anche per gestire gli errori quando si utilizzano funzioni asincrone.

 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 questo esempio, i dati vengono recuperati utilizzando fetch, e viene controllato response.ok per generare un errore se il codice di stato non è OK. L'errore viene catturato in catch e viene visualizzato il log appropriato.

Riepilogo

In TypeScript, utilizzare i tipi per chiarire il contenuto degli errori rende la gestione degli stessi più sicura e leggibile. Quando si gestiscono errori, è importante chiarire quali tipi di errori potrebbero verificarsi e gestirli di conseguenza.

Errore

La classe Error in TypeScript estende la classe Error in JavaScript ed è un oggetto base per rappresentare gli errori. Utilizzando la classe Error, è possibile creare un oggetto che include un messaggio di errore ed eseguire la gestione degli errori.

Basi della classe Error

La classe Error viene usata come segue.

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

Proprietà

La classe Error possiede le seguenti proprietà:.

• messaggio Una stringa che rappresenta il messaggio di errore.
• nome Il nome dell’errore. Per impostazione predefinita, è "Error", ma può essere modificato creando una classe di errore personalizzata.
• stack Informazioni sullo stack trace utilizzate per il debug. Una stringa che indica quale codice ha causato l'errore al momento dell'occorrenza.

Classe di Errore Personalizzata

È anche possibile estendere la classe Error e creare le proprie classi di errore. Questo è utile in situazioni in cui è necessaria una gestione specifica degli errori. Ad esempio, è efficace quando si vogliono gestire diversi tipi di errori come gli errori delle richieste HTTP o degli errori del database.

Esempio di Creazione di un Errore Personalizzato

 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

• Creando una classe CustomError e aggiungendo informazioni come i codici di errore, è possibile gestire informazioni più dettagliate sugli errori.

Eredità della Classe Error

In TypeScript, quando si crea una classe di errore personalizzata estendendo la classe Error, ci sono alcuni punti di cui essere cauti.

1. Chiamare super() Nel costruttore di una classe di errore personalizzata, è necessario chiamare super() per invocare il costruttore della classe Error. Questo garantisce che le proprietà message e stack siano inizializzate correttamente.

2. Aggiunta di Proprietà Se desideri aggiungere informazioni aggiuntive all’oggetto errore, definisci nuove proprietà all’interno della classe. Ad esempio, nel CustomError sopra riportato, è stata aggiunta una proprietà errorCode.

Lanciare e Gestire gli Errori

Puoi gestire gli errori generandoli tramite la classe Error o una classe di errore personalizzata e quindi intercettandoli.

 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}

Anche nel caso di errori personalizzati, utilizzare instanceof per identificare errori specifici e gestirli adeguatamente.

 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}

Riepilogo

La classe Error in TypeScript è una classe fondamentale per eseguire la gestione standard degli errori. Inoltre, estendendo la classe Error per creare errori personalizzati, diventa possibile una gestione flessibile degli errori basata sui tipi di errore e su informazioni aggiuntive.

Puoi seguire l'articolo sopra utilizzando Visual Studio Code sul nostro canale YouTube. Controlla anche il nostro canale YouTube.

YouTube Video