Guide de gestion des erreurs TypeScript pour débutants

Une gestion efficace des erreurs est essentielle dans tout langage de programmation, et TypeScript ne fait pas exception. Une gestion appropriée des erreurs permet de créer des applications robustes et fiables en gérant les conditions inattendues avec élégance. Ce guide couvrira les bases de la gestion des erreurs dans TypeScript et fournira des exemples pratiques pour les débutants.

Comprendre les erreurs dans TypeScript

Les erreurs dans TypeScript, comme dans JavaScript, se produisent lors de l'exécution ou de la compilation. TypeScript offre une sécurité de type qui peut détecter de nombreux problèmes potentiels au moment de la compilation, mais les erreurs d'exécution doivent toujours être gérées correctement.

Gestion des erreurs de base avec try et catch

Dans TypeScript, vous gérez les erreurs d'exécution à l'aide des blocs try et catch. Cette approche vous permet d'exécuter du code susceptible de générer une erreur et de gérer cette erreur si elle se produit.

Exemple de try et catch

function divide(a: number, b: number): number {
  try {
    if (b === 0) {
      throw new Error("Cannot divide by zero");
    }
    return a / b;
  } catch (error) {
    console.error(error.message);
    return NaN; // Return NaN to indicate an error
  }
}

console.log(divide(10, 2)); // Output: 5
console.log(divide(10, 0)); // Output: Cannot divide by zero

Dans cet exemple, la fonction divide tente de diviser deux nombres. Si le diviseur est nul, une erreur est générée et interceptée par le bloc catch, qui enregistre un message d'erreur.

Types d'erreur personnalisés

TypeScript vous permet de définir des types d'erreur personnalisés pour mieux représenter des conditions d'erreur spécifiques. Les types d'erreur personnalisés permettent de catégoriser les erreurs et de les gérer plus efficacement.

Créer un type d'erreur personnalisé

class DivisionError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "DivisionError";
  }
}

function divide(a: number, b: number): number {
  try {
    if (b === 0) {
      throw new DivisionError("Cannot divide by zero");
    }
    return a / b;
  } catch (error) {
    if (error instanceof DivisionError) {
      console.error(`Custom Error: ${error.message}`);
    } else {
      console.error("An unexpected error occurred");
    }
    return NaN; // Return NaN to indicate an error
  }
}

console.log(divide(10, 2)); // Output: 5
console.log(divide(10, 0)); // Output: Custom Error: Cannot divide by zero

Ici, nous définissons une classe d'erreur personnalisée DivisionError qui étend la classe intégrée Error. Nous utilisons cette erreur personnalisée dans la fonction divide pour fournir une gestion des erreurs plus spécifique.

Protection de type avec instanceof

Les protections de type comme instanceof aident à affiner le type d'un objet d'erreur dans le bloc catch, vous permettant de gérer différents types d'erreurs différemment.

Exemple de protection de type

function processInput(input: string | number) {
  try {
    if (typeof input === "string") {
      console.log(input.toUpperCase());
    } else {
      throw new Error("Input must be a string");
    }
  } catch (error) {
    if (error instanceof Error) {
      console.error(`Error: ${error.message}`);
    } else {
      console.error("An unknown error occurred");
    }
  }
}

processInput("hello"); // Output: HELLO
processInput(42); // Output: Error: Input must be a string

Cet exemple illustre la protection de type dans le bloc catch pour garantir que l'objet d'erreur est une instance de Error, permettant une gestion précise des erreurs.

Utilisation de finally pour le nettoyage

Le bloc finally peut être utilisé pour exécuter du code qui doit s'exécuter indépendamment du fait qu'une erreur se soit produite ou non. Ceci est utile pour les opérations de nettoyage telles que la fermeture de fichiers ou la libération de ressources.

Exemple avec finally

function readFile(filePath: string): string {
  try {
    // Simulate reading a file
    if (filePath === "") {
      throw new Error("File path cannot be empty");
    }
    return "File content";
  } catch (error) {
    console.error(`Error: ${error.message}`);
    return "";
  } finally {
    console.log("Cleanup: Closing file");
  }
}

console.log(readFile("path/to/file")); // Output: File content
console.log(readFile("")); // Output: Error: File path cannot be empty
                            //         Cleanup: Closing file

Dans cet exemple, le bloc finally garantit qu'un message de nettoyage est enregistré, qu'une erreur se produise ou non.

Conclusion

Une gestion efficace des erreurs est essentielle pour créer des applications TypeScript fiables. En utilisant try et catch, des types d'erreur personnalisés, la protection de type et finally, vous pouvez gérer les erreurs plus efficacement et garantir que votre application se comporte de manière prévisible même face à des conditions inattendues.

Grâce à ces techniques, vous pouvez gérer les erreurs avec élégance et améliorer la robustesse de votre code TypeScript. Mettez en pratique ces concepts pour maîtriser la gestion des erreurs TypeScript et écrire des applications plus résilientes.