Foutafhandeling in TypeScript

Dit artikel legt foutafhandeling in TypeScript uit.

YouTube Video

Foutafhandeling in TypeScript

Foutafhandeling in TypeScript wordt fundamenteel uitgevoerd met de try...catch-constructie, net zoals in JavaScript. In TypeScript is het mogelijk om foutinhoud duidelijker te beheren via type-inferentie. Dit maakt nauwkeurige en beter leesbare foutafhandeling mogelijk.

try...catch Syntax

De basissyntax voor foutafhandeling is als volgt:.

 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-veilige foutafhandeling

In TypeScript worden fouten die binnen een catch-blok worden opgevangen als het any-type behandeld, maar het wordt aanbevolen om een geschikt type te specificeren voor veiligere foutafhandeling. Bijvoorbeeld, je kunt een aangepast fouttype definiëren en gebruiken als volgt:.

 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 dit voorbeeld wordt een klasse genaamd CustomError gemaakt en wordt er een fout gegenereerd met aangepaste eigenschappen zoals errorCode. Gebruik in het catch-blok instanceof om het type fout te bepalen en de juiste afhandeling uit te voeren.

Asynchrone foutafhandeling

In TypeScript wordt try...catch ook gebruikt om fouten af te handelen bij het gebruik van asynchrone functies.

 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 dit voorbeeld worden gegevens opgehaald met fetch, en wordt response.ok gecontroleerd om een fout op te gooien als de statuscode niet OK is. De fout wordt opgevangen in catch, en de juiste log wordt uitgegeven.

Samenvatting

In TypeScript maakt het gebruik van types om foutinhoud te verduidelijken foutafhandeling veiliger en beter leesbaar. Bij het afhandelen van fouten is het belangrijk om te verduidelijken welke soorten fouten kunnen optreden en deze dienovereenkomstig af te handelen.

Fout

De Error-klasse in TypeScript breidt de Error-klasse in JavaScript uit en is een basisobject voor het vertegenwoordigen van fouten. Door de Error-klasse te gebruiken, kun je een object maken dat een foutbericht bevat en foutafhandeling uitvoeren.

Basisprincipes van de Error-klasse

De Error-klasse wordt als volgt gebruikt.

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

Eigenschappen

De klasse Error heeft de volgende eigenschappen:.

• bericht Een tekenreeks die het foutbericht weergeeft.
• naam De naam van de fout. Standaard is het "Error", maar dit kan worden aangepast door een aangepaste foutklasse te maken.
• stack Stacktrace-informatie die wordt gebruikt voor het debuggen. Een string die aangeeft welke code de fout veroorzaakte op het moment dat deze optrad.

Aangepaste Foutklasse

Het is ook mogelijk om de Error-klasse uit te breiden en je eigen foutklassen te maken. Dit is nuttig in situaties waarin specifieke foutafhandeling vereist is. Het is bijvoorbeeld effectief wanneer je verschillende soorten fouten wilt afhandelen, zoals HTTP-aanvraagfouten of databasefouten.

Voorbeeld van het Maken van een Aangepaste Fout

 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

• Door een CustomError-klasse te maken en informatie zoals foutcodes toe te voegen, kun je uitgebreidere informatie over fouten beheren.

Overerving van de Error-klasse

In TypeScript, bij het maken van een aangepaste foutklasse door de Error-klasse uit te breiden, zijn er enkele belangrijke aandachtspunten.

1. Het aanroepen van super() In de constructor van een aangepaste foutklasse moet je super() aanroepen om de constructor van de klasse Error op te roepen. Dit zorgt ervoor dat de eigenschappen message en stack correct worden geïnitialiseerd.

2. Eigenschappen toevoegen Als je extra informatie aan het foutobject wilt toevoegen, definieer je nieuwe eigenschappen binnen de klasse. In het bovenstaande voorbeeld van CustomError wordt bijvoorbeeld een eigenschap errorCode toegevoegd.

Errors Gooien en Afvangen

Je kunt fouten afhandelen door fouten te genereren met de klasse Error of een aangepaste foutklasse en deze vervolgens op te vangen.

 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}

Ook in het geval van aangepaste fouten kun je instanceof gebruiken om specifieke fouten te identificeren en ze correct af te handelen.

 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}

Samenvatting

De Error-klasse in TypeScript is een fundamentele klasse voor het uitvoeren van standaard foutafhandeling. Bovendien wordt flexibele foutafhandeling op basis van fouttypes en aanvullende informatie mogelijk door de Error-klasse uit te breiden voor het maken van aangepaste fouten.

Je kunt het bovenstaande artikel volgen met Visual Studio Code op ons YouTube-kanaal. Bekijk ook het YouTube-kanaal.

YouTube Video