Gestion des erreurs dans TypeScript

Cet article explique la gestion des erreurs dans TypeScript.

YouTube Video

Gestion des erreurs dans TypeScript

La gestion des erreurs dans TypeScript est essentiellement effectuée à l'aide de la structure try...catch, comme en JavaScript. Dans TypeScript, il est possible de gérer plus clairement le contenu des erreurs grâce à l'inférence des types. Cela permet une gestion des erreurs plus précise et lisible.

Syntaxe de try...catch

La syntaxe de base pour la gestion des erreurs est la suivante :.

 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}

Gestion des erreurs avec sécurité de type

Dans TypeScript, les erreurs capturées dans un bloc catch sont traitées comme le type any, mais il est recommandé de spécifier le type approprié pour une gestion des erreurs plus sûre. Par exemple, vous pouvez définir et utiliser un type d'erreur personnalisé comme suit :.

 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}

Dans cet exemple, une classe appelée CustomError est créée, et une erreur est levée avec des propriétés personnalisées telles que errorCode. Dans le bloc catch, utilisez instanceof pour déterminer le type d'erreur et effectuer le traitement approprié.

Gestion des erreurs asynchrones

En TypeScript, try...catch est aussi utilisé pour gérer les erreurs lors de l’utilisation de fonctions asynchrones.

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

Dans cet exemple, les données sont récupérées à l'aide de fetch, et response.ok est vérifié pour lever une erreur si le code de statut n'est pas OK. L'erreur est capturée dans le bloc catch, et le journal approprié est affiché.

Résumé

Dans TypeScript, l'utilisation de types pour clarifier le contenu des erreurs rend la gestion des erreurs plus sûre et plus lisible. Lors de la gestion des erreurs, il est important de clarifier quels types d'erreurs peuvent se produire et de les gérer en conséquence.

Erreur

La classe Error dans TypeScript étend la classe Error dans JavaScript et est un objet de base pour représenter les erreurs. En utilisant la classe Error, vous pouvez créer un objet contenant un message d'erreur et effectuer une gestion des erreurs.

Notions de base de la classe Error

La classe Error est utilisée comme suit.

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

Propriétés

La classe Error possède les propriétés suivantes :.

• message Une chaîne de caractères représentant le message d’erreur.
• name Le nom de l’erreur. Par défaut, c'est "Error", mais cela peut être modifié en créant une classe d'erreur personnalisée.
• stack Informations sur la pile d’appel utilisées pour le débogage. Une chaîne indiquant le code qui a provoqué l'erreur lorsqu'elle s'est produite.

Classe d'erreur personnalisée

Il est aussi possible d'étendre la classe Error et de créer vos propres classes d'erreurs. Ceci est utile dans les situations nécessitant une gestion spécifique des erreurs. Par exemple, cela est efficace lorsque vous souhaitez gérer différents types d'erreurs comme les erreurs de requêtes HTTP ou les erreurs de base de données.

Exemple de création d'une erreur personnalisée

 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

• En créant une classe CustomError et en ajoutant des informations telles que des codes d'erreur, vous pouvez gérer des informations plus détaillées sur les erreurs.

Héritage de la classe Error

En TypeScript, lors de la création d'une classe d'erreur personnalisée en étendant la classe Error, il y a quelques points auxquels il faut faire attention.

1. Appel de super() Dans le constructeur d’une classe d’erreur personnalisée, vous devez appeler super() pour invoquer le constructeur de la classe Error. Cela garantit que les propriétés message et stack sont correctement initialisées.

2. Ajout de Propriétés Si vous souhaitez ajouter des informations supplémentaires à l’objet d’erreur, définissez de nouvelles propriétés dans la classe. Par exemple, dans le CustomError ci-dessus, une propriété errorCode est ajoutée.

Lancer et capturer des erreurs

Vous pouvez gérer les erreurs en lançant des erreurs à l’aide de la classe Error ou d’une classe d’erreur personnalisée, puis en les interceptant.

 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}

Dans le cas des erreurs personnalisées également, utilisez instanceof pour identifier les erreurs spécifiques et les gérer correctement.

 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}

Résumé

La classe Error en TypeScript est une classe fondamentale pour effectuer une gestion standard des erreurs. De plus, en étendant la classe Error pour créer des erreurs personnalisées, une gestion flexible basée sur les types d'erreurs et des informations supplémentaires devient possible.

Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.

YouTube Video