Gestion des erreurs en TypeScript : try/catch et bien plus : de A à Z

Gestion des erreurs en TypeScript : de try/catch aux scénarios complexes

TypeScript, en tant que surcouche de JavaScript, hérite et étend les mécanismes de gestion des erreurs. Une gestion correcte des exceptions est la clé d'une application stable et prévisible. Dans cet article, nous aborderons tous les aspects du travail avec les erreurs : du try/catch de base à la création de vos propres classes d'erreurs typées et aux stratégies avancées.

Syntaxe de base : try, catch, finally

Le mécanisme principal de gestion des erreurs en TypeScript (comme en JavaScript) est la construction try...catch...finally. Elle permet d'intercepter les exceptions qui se produisent dans le code et d'y réagir.

function parseJSON(data: string): object {    try {        return JSON.parse(data);    } catch (error) {        console.error('Erreur d\'analyse JSON :', error);        return {};    }}

parseJSON('{"name": "TypeScript"}'); // { name: 'TypeScript' }parseJSON('JSON invalide');        // {} (erreur interceptée)

Le bloc finally s'exécute dans tous les cas — aussi bien après la réussite du try qu'après l'interception d'une erreur. C'est l'endroit idéal pour le nettoyage des ressources (fermeture de fichiers, connexions).

function processData(data: string): void {    let resource: any = null;    try {        resource = acquireResource();        // ... code dangereux    } catch (error) {        console.error('Erreur de traitement :', error);    } finally {        if (resource) {            resource.release(); // nettoyage garanti        }    }}

Typage des erreurs : le problème de unknown

Une caractéristique clé de TypeScript — dans le bloc catch, la variable error a par défaut le type unknown (depuis TS 4.0). Cela a été fait intentionnellement pour forcer le développeur à vérifier explicitement le type de l'erreur, plutôt que de supposer qu'il s'agit d'une Error.

try {    // du code} catch (error) {    // error a le type unknown    // Erreur : la propriété 'message' n'existe pas sur le type 'unknown'    // console.log(error.message);

    // Approche correcte — vérification du type    if (error instanceof Error) {        console.log('Message :', error.message);    } else {        console.log('Erreur inconnue :', error);    }}

Pourquoi est-ce important ? En JavaScript, le bloc catch peut recevoir n'importe quoi : une chaîne, un nombre, un objet, null ou même undefined. La vérification de type obligatoire protège contre les erreurs lors de l'exécution.

Création de classes d'erreurs personnalisées

Pour les applications complexes, il est souvent nécessaire de distinguer les types d'erreurs. En TypeScript, il est facile de créer une hiérarchie de vos propres classes d'erreurs, étendant l'Error intégrée.

// Classe de base pour les erreurs d'applicationclass AppError extends Error {    public readonly statusCode: number;    public readonly isOperational: boolean;

    constructor(message: string, statusCode: number = 500, isOperational: boolean = true) {        super(message);        this.name = this.constructor.name;        this.statusCode = statusCode;        this.isOperational = isOperational;

        // Restauration du prototype (important pour instanceof)        Object.setPrototypeOf(this, new.target.prototype);    }}

// Types d'erreurs spécifiquesclass ValidationError extends AppError {    public readonly field: string;

    constructor(message: string, field: string) {        super(message, 400);        this.field = field;    }}

class NotFoundError extends AppError {    constructor(message: string = 'Ressource non trouvée') {        super(message, 404);    }}

// Utilisationfunction getUser(id: number): User {    if (id <= 0) {        throw new ValidationError('L\'ID doit être un nombre positif', 'id');    }    // ... recherche de l'utilisateur    throw new NotFoundError