Feilhåndtering i TypeScript

Denne artikkelen forklarer feilhåndtering i TypeScript.

YouTube Video

Feilhåndtering i TypeScript

Feilhåndtering i TypeScript gjøres grunnleggende ved hjelp av try...catch-konstruksjonen, akkurat som i JavaScript. I TypeScript er det mulig å håndtere innholdet i feil mer tydelig ved hjelp av typeinferenz. Dette muliggjør mer presis og lesbar feilhåndtering.

try...catch-syntaks

Den grunnleggende syntaksen for feilhå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}

Typesikker feilhåndtering

I TypeScript behandles feil fanget i en catch-blokk som typen any, men det anbefales å spesifisere riktig type for tryggere feilhåndtering. For eksempel kan du definere og bruke en tilpasset feiltype 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 eksemplet opprettes en klasse kalt CustomError, og en feil kastes med egendefinerte egenskaper som errorCode. I catch-blokken kan du bruke instanceof for å avgjøre hvilken type feil det er og utføre passende håndtering.

Asynkron feilhåndtering

I TypeScript brukes try...catch også for å håndtere feil når du bruker asynkrone funksjoner.

 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 eksempelet hentes data ved hjelp av fetch, og response.ok kontrolleres for å kaste en feil hvis statuskoden ikke er OK. Feilen fanges opp i catch, og riktig logg skrives ut.

Sammendrag

I TypeScript gjør bruk av typer for å tydeliggjøre feilinnhold feilhåndteringen tryggere og mer lesbar. Når man håndterer feil, er det viktig å avklare hvilke typer feil som kan oppstå og håndtere dem deretter.

Feil

Error-klassen i TypeScript utvider Error-klassen i JavaScript og er et grunnleggende objekt for å representere feil. Ved å bruke Error-klassen kan du opprette et objekt som inkluderer en feilmelding og utføre feilhåndtering.

Grunnleggende om Error-klassen

Error-klassen brukes som følger.

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

Egenskaper

Error-klassen har følgende egenskaper:.

• melding En streng som representerer feilmeldingen.
• navn Navnet på feilen. Som standard er det "Error", men dette kan endres ved å opprette en tilpasset feilklasse.
• stack Stack-trace-informasjon brukt til feilsøking. En streng som indikerer hvilken kode som forårsaket feilen da den oppstod.

Tilpasset Feilklasse

Det er også mulig å utvide Error-klassen og opprette egne feilklasser. Dette er nyttig i situasjoner hvor spesifikk feilbehandling er nødvendig. For eksempel er det effektivt når du vil håndtere forskjellige typer feil som HTTP-forespørselsfeil eller databasefeil.

Eksempel på Opprettelse av en Tilpasset Feilklasse

 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 å opprette en CustomError-klasse og legge til informasjon som feilkoder, kan du håndtere mer omfattende informasjon om feil.

Arv av Error-Klassen

I TypeScript, når du oppretter en tilpasset feilklasse ved å utvide Error-klassen, er det noen ting du bør være oppmerksom på.

1. Kalle på super() I konstruktøren til en egendefinert feilmelding-klasse må du kalle super() for å bruke konstruktøren til Error-klassen. Dette sikrer at melding- og stakk-egenskapene er korrekt initialisert.

2. Legge til egenskaper Hvis du vil legge til ekstra informasjon til feilobjektet, definerer du nye egenskaper i klassen. For eksempel, i den ovenstående CustomError, er en errorCode-egenskap lagt til.

Kaste og Fange Feil

Du kan håndtere feil ved å kaste feil med Error-klassen eller en egendefinert feilklasse, og deretter 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}

Også i tilfelle av tilpassede feil, bruk instanceof for å identifisere spesifikke feil og håndtere dem på riktig måte.

 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 grunnleggende klasse for å utføre standard feilbehandling. Videre, ved å utvide Error-klassen for å opprette tilpassede feil, blir fleksibel feilbehandling basert på feiltyper og tilleggsinformasjon mulig.

Du kan følge med på artikkelen ovenfor ved å bruke Visual Studio Code på vår YouTube-kanal. Vennligst sjekk ut YouTube-kanalen.

YouTube Video