Felhantering i TypeScript

Den här artikeln förklarar felhantering i TypeScript.

YouTube Video

Felhantering i TypeScript

Felhantering i TypeScript görs i grunden med hjälp av try...catch-konstruktionen, precis som i JavaScript. I TypeScript är det möjligt att hantera felförhållanden tydligare genom typinferens. Detta möjliggör mer exakt och läsbar felhantering.

try...catch-syntax

Den grundläggande syntaxen för felhantering är följande:.

 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}

Typsäker felhantering

I TypeScript behandlas fel som fångas inom en catch-block som any-typen, men det rekommenderas att specificera den lämpliga typen för säkrare felhantering. Till exempel kan du definiera och använda en anpassad feltyp enligt följande:.

 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 det här exemplet skapas en klass som heter CustomError, och ett fel kastas med anpassade egenskaper som errorCode. I catch-blocket använder du instanceof för att bestämma typen av fel och utföra lämplig hantering.

Asynkron felhantering

I TypeScript används try...catch också för att hantera fel när man använder asynkrona 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 detta exempel hämtas data med fetch, och response.ok kontrolleras för att kasta ett fel om statuskoden inte är OK. Felet fångas i catch, och den lämpliga loggen skrivs ut.

Sammanfattning

I TypeScript gör användningen av typer för att klargöra felinnehåll felhanteringen säkrare och mer läsbar. Vid hantering av fel är det viktigt att klargöra vilka typer av fel som kan uppstå och hantera dem därefter.

Fel

Error-klassen i TypeScript utökar Error-klassen i JavaScript och är ett grundläggande objekt för att representera fel. Genom att använda Error-klassen kan du skapa ett objekt som innehåller ett felmeddelande och utföra felhantering.

Grunderna i Error-klassen

Error-klassen används enligt följande.

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

Egenskaper

Error-klassen har följande egenskaper:.

• meddelande En sträng som representerar felmeddelandet.
• namn Namnet på felet. Som standard är det "Error", men det kan ändras genom att skapa en anpassad felklass.
• stack Stackspårningsinformation som används för felsökning. En sträng som anger vilken kod som orsakade felet när det inträffade.

Anpassad Felklass

Det är också möjligt att utöka Error-klassen och skapa egna felklasser. Detta är användbart i situationer där specifik felhantering krävs. Till exempel är det effektivt när du vill hantera olika typer av fel som HTTP-förfrågningsfel eller databashanteringsfel.

Exempel på att skapa ett anpassat fel

 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

• Genom att skapa en CustomError-klass och lägga till information som felkoder kan du hantera mer omfattande information om fel.

Arv av Error-klassen

I TypeScript, när man skapar en anpassad felklass genom att utöka Error-klassen, finns det några saker att vara försiktig med.

1. Anropa super() I konstruktorn för en anpassad felklass måste du anropa super() för att köra konstruktorn för Error-klassen. Detta säkerställer att message- och stack-egenskaperna är korrekt initialiserade.

2. Lägga till egenskaper Om du vill lägga till extra information i felobjektet, definiera nya egenskaper i klassen. Till exempel, i ovanstående CustomError, läggs en errorCode-egenskap till.

Kasta och fånga fel

Du kan hantera fel genom att kasta fel med hjälp av Error-klassen eller en anpassad felklass och sedan fånga 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}

Även för anpassade fel, använd instanceof för att identifiera specifika fel och hantera dem på lämpligt sätt.

 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}

Sammanfattning

Error-klassen i TypeScript är en grundläggande klass för att utföra standardfelhantering. Genom att utöka Error-klassen för att skapa anpassade fel möjliggörs flexibel felhantering baserad på feltyper och ytterligare information.

Du kan följa med i artikeln ovan med hjälp av Visual Studio Code på vår YouTube-kanal. Vänligen kolla även in YouTube-kanalen.

YouTube Video