Fejlhåndtering i TypeScript

Denne artikel forklarer fejlhåndtering i TypeScript.

YouTube Video

Fejlhåndtering i TypeScript

Fejlhåndtering i TypeScript udføres grundlæggende ved hjælp af try...catch-strukturen, ligesom i JavaScript. I TypeScript er det muligt at håndtere fejlinhold mere klart ved hjælp af typeinferens. Dette muliggør mere præcis og læsbar fejlhåndtering.

try...catch-syntaks

Den grundlæggende syntaks for fejlhåndtering er som følger:.

 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}

Type-sikker fejlhåndtering

I TypeScript behandles fejl fanget i en catch-blok som typen any, men det anbefales at specificere den passende type for mere sikker fejlhåndtering. For eksempel kan du definere og bruge en brugerdefineret fejrtype som følger:.

 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}

I dette eksempel oprettes en klasse kaldet CustomError, og en fejl kastes med tilpassede egenskaber som errorCode. I catch-blokken kan du bruge instanceof til at bestemme fejlenstype og udføre passende håndtering.

Asynkron fejlhåndtering

I TypeScript bruges try...catch også til at håndtere fejl, når der anvendes asynkrone funktioner.

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

I dette eksempel hentes data ved hjælp af fetch, og response.ok kontrolleres for at kaste en fejl, hvis statuskoden ikke er OK. Fejlen fanges i catch, og den relevante log genereres.

Sammendrag

I TypeScript gør brugen af typer til at tydeliggøre fejlinhold fejlhåndtering mere sikker og læsbar. Når man håndterer fejl, er det vigtigt at tydeliggøre, hvilke typer fejl der kan opstå, og håndtere dem i overensstemmelse hermed.

Fejl

Error-klassen i TypeScript udvider Error-klassen i JavaScript og er et grundlæggende objekt til at repræsentere fejl. Ved hjælp af Error-klassen kan du oprette et objekt, der inkluderer en fejlmeddelelse, og udføre fejlhåndtering.

Grundlæggende om Error-klassen

Error-klassen bruges som følger.

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

Egenskaber

Error-klassen har følgende egenskaber:.

• meddelelse En streng, der repræsenterer fejlmeddelelsen.
• navn Navnet på fejlen. Som standard er det "Error", men det kan ændres ved at oprette en brugerdefineret fejleklasse.
• stack Stack trace-information bruges til fejlfinding. En streng, der angiver, hvilken kode der forårsagede fejlen, da den opstod.

Brugerdefineret Fejlklasse

Det er også muligt at udvide Error-klassen og oprette dine egne fejleklasser. Dette er nyttigt i situationer, hvor specifik fejlhåndtering er påkrævet. For eksempel er det effektivt, når du vil håndtere forskellige typer fejl som HTTP-anmodningsfejl eller databasefejl.

Eksempel på at oprette en brugerdefineret fejl

 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

• Ved at oprette en CustomError-klasse og tilføje information såsom fejlkoder, kan du håndtere mere omfattende information om fejl.

Arv fra Error-klassen

I TypeScript, når du opretter en brugerdefineret fejleklasse ved at udvide Error-klassen, er der nogle punkter at være opmærksom på.

1. Kald af super() I konstruktøren for en brugerdefineret fejlass, skal du kalde super() for at påkalde konstruktøren af Error-klassen. Dette sikrer, at message- og stack-egenskaberne initialiseres korrekt.

2. Tilføjelse af egenskaber Hvis du vil tilføje ekstra information til fejlobjektet, skal du definere nye egenskaber i klassen. For eksempel, i den ovenstående CustomError, er en errorCode-egenskab tilføjet.

At kaste og fange fejl

Du kan håndtere fejl ved at kaste fejl med Error-klassen eller en brugerdefineret fejlass og derefter fange dem.

 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}

I tilfælde af brugerdefinerede fejl skal du også bruge instanceof til at identificere specifikke fejl og håndtere dem passende.

 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}

Sammendrag

Error-klassen i TypeScript er en grundlæggende klasse til at udføre standardfejlhåndtering. Desuden bliver det muligt med fleksibel fejlhåndtering baseret på fejltyper og yderligere information ved at udvide Error-klassen til at oprette brugerdefinerede fejl.

Du kan følge med i ovenstående artikel ved hjælp af Visual Studio Code på vores YouTube-kanal. Husk også at tjekke YouTube-kanalen.

YouTube Video