Gestion des erreurs en TypeScript : try/catch et méthodes avancées

Gestion des erreurs en TypeScript : de try/catch à un code fiable

TypeScript ajoute du typage statique à JavaScript, mais les erreurs d'exécution restent une partie intégrante du développement. Une gestion incorrecte des exceptions peut entraîner des plantages de l'application, des fuites de données ou un comportement incorrect de l'interface utilisateur. Dans cet article, nous allons explorer comment gérer efficacement les erreurs en TypeScript en utilisant des mécanismes intégrés et des motifs avancés.

try/catch de base en TypeScript

La construction try/catch est le fondement de la gestion des erreurs. En TypeScript, contrairement à JavaScript, nous pouvons typer l'erreur interceptée. Cependant, il y a une nuance importante : par défaut, le type de l'erreur dans le bloc catch est unknown, et non Error.

try {    const data = JSON.parse('invalid json');    console.log(data);} catch (error) {    // error a le type unknown    if (error instanceof Error) {        console.error('Une erreur est survenue :', error.message);    } else {        console.error('Erreur inconnue :', error);    }}

Pourquoi est-ce important ? En JavaScript, vous pouvez lancer n'importe quoi : une chaîne, un nombre, un objet. TypeScript nous protège d'un accès non sécurisé aux propriétés de l'erreur sans vérification. Il est recommandé de toujours vérifier le type de l'erreur avant de l'utiliser.

Classes d'erreur personnalisées

Pour une gestion plus précise, créez vos propres classes d'erreur étendant l'Error intégrée. Cela permet de distinguer les types d'erreur et de transmettre des informations supplémentaires.

class ValidationError extends Error {    constructor(        public field: string,        message: string    ) {        super(message);        this.name = 'ValidationError';    }}

class NetworkError extends Error {    constructor(        public statusCode: number,        message: string    ) {        super(message);        this.name = 'NetworkError';    }}

function processUserData(data: unknown): void {    if (!data || typeof data !== 'object') {        throw new ValidationError('data', 'Données invalides');    }        if (!('email' in data)) {        throw new ValidationError('email', 'L\'email est requis');    }}

try {    processUserData({ name: 'Ivan' });} catch (error) {    if (error instanceof ValidationError) {        console.error(`Erreur de validation dans le champ ${error.field} : ${error.message}`);    } else if (error instanceof NetworkError) {        console.error(`Erreur réseau ${error.statusCode} : ${error.message}`);    } else {        console.error('Erreur inconnue :', error);    }}

Cette approche rend le code auto-documenté et simplifie le débogage. Vous savez toujours où et pourquoi une erreur s'est produite.

Typage des fonctions avec les erreurs : never et les unions discriminées

TypeScript fournit des outils puissants pour travailler avec les erreurs au niveau des types. Utilisez le type never pour les fonctions qui lèvent toujours une exception, et les unions discriminées pour retourner des erreurs.

function throwError(message: string): never {    throw new Error(message);}

// Union discriminée pour le résultattype Result<T> =     | { success: true; data: T }    | { success: false; error: string };

function fetchUser(id: number): Result<{ name: string }> {    try {        // Simulation d'une requête        if (id <= 0) {            return { success: false, error: 'ID invalide' };        }        return { success: true, data: { name: 'Anna' } };    } catch (error) {        return { success: false, error: 'Erreur réseau' };    }}

const result = fetchUser(1);if (result.success) {    console.log('Utilisateur :', result.data.name);} else {    console.error('Erreur :', result.error);}

Le motif Result permet d'éviter les exceptions implicites et rend la gestion des erreurs