La gestion efficace des erreurs est cruciale pour créer des applications robustes. Avec TypeScript, vous pouvez tirer parti de son typage statique et de ses fonctionnalités avancées pour écrire un code plus maintenable et plus fiable. Ce guide détaillé vous guidera à travers divers conseils et bonnes pratiques pour la gestion des erreurs dans TypeScript, en expliquant chacun en profondeur.
1. Utiliser judicieusement les blocs try…catch
Le essayez… attrapez construct est un outil de base pour la gestion des erreurs. Cependant, il doit être utilisé avec précaution pour maintenir la clarté et les performances du code.
Explication:
- Lieu essayez… attrapez bloque uniquement là où des erreurs sont susceptibles de se produire, comme lors des appels réseau ou des opérations sur les fichiers.
- Évitez d’encapsuler de grandes sections de code, car cela peut rendre le débogage plus difficile.
Exemple:
async function fetchData(url: string): Promise<void> {
try {
const response = await fetch(url);
if (!response.ok) {
throw new Error(`HTTP Error: ${response.status}`);
}
const data = await response.json();
console.log(data);
} catch (error) {
console.error('Error fetching data:', error);
}
}
Ici, les erreurs sont gérées localement au sein de la fonction, ce qui lui permet d’échouer correctement sans faire planter l’application.
2. Définir des classes d’erreurs personnalisées
Les classes d’erreurs personnalisées offrent une meilleure catégorisation, ce qui facilite la différenciation entre les différents types d’erreurs.
Explication:
En étendant le module intégré Erreur classe, vous pouvez ajouter des propriétés ou des méthodes personnalisées aux erreurs. Ceci est particulièrement utile pour faire la distinction entre les erreurs spécifiques à l’application et les erreurs système.
Exemple:
class ValidationError extends Error {
constructor(message: string) {
super(message);
this.name = 'ValidationError';
}
}
try {
throw new ValidationError('Invalid input data');
} catch (error) {
if (error instanceof ValidationError) {
console.error('Validation Error:', error.message);
} else {
console.error('Unexpected Error:', error);
}
}
Avec Erreur de validation, vous pouvez gérer explicitement les erreurs liées à une saisie non valide, fournissant ainsi des commentaires plus ciblés.
3. Utiliser des types d’union pour les réponses d’erreur
Les types d’union vous permettent de gérer explicitement les cas de réussite et d’échec, améliorant ainsi la clarté et réduisant les contrôles d’exécution.
Explication:
Les types d’union permettent de garantir que tous les résultats possibles d’une fonction sont pris en compte. Cela évite les situations dans lesquelles une fonction échoue silencieusement ou renvoie des résultats inattendus.
Exemple:
type Result<T> = { success: true; data: T } | { success: false; error: string };
function performTask(): Result<number> {
if (Math.random() > 0.5) {
return { success: true, data: 42 };
} else {
return { success: false, error: 'Task failed' };
}
}
const result = performTask();
if (result.success) {
console.log('Data:', result.data);
} else {
console.error('Error:', result.error);
}
Dans cette approche, le Résultat type impose la gestion explicite des scénarios de réussite et d’erreur.
4. Exploiter never pour un traitement exhaustif des erreurs
Le jamais type garantit que vous gérez tous les cas possibles dans votre logique de gestion des erreurs.
Explication:
Lorsqu’il s’agit de types de syndicats ou de cas de changement, jamais agit comme une protection pour détecter les scénarios non gérés au moment de la compilation.
Exemple:
type AppError = ValidationError | SyntaxError;
function handleAppError(error: AppError): void {
switch (error.name) {
case 'ValidationError':
console.error('Validation error:', error.message);
break;
case 'SyntaxError':
console.error('Syntax error:', error.message);
break;
default:
const exhaustiveCheck: never = error;
throw new Error(`Unhandled error: ${exhaustiveCheck}`);
}
}
Le défaut case garantit qu’aucun type d’erreur n’est laissé sans traitement. Si vous ajoutez un nouveau type d’erreur, TypeScript signalera ce code comme incomplet, vous invitant à gérer le nouveau type.
5. Mettre en œuvre une gestion centralisée des erreurs
La gestion centralisée des erreurs réduit la duplication de code et fournit une stratégie unifiée pour gérer les erreurs d’application.
Explication:
La gestion centralisée des erreurs est particulièrement utile dans des frameworks comme Express ou NestJS, où vous pouvez définir un middleware ou un filtre global de gestion des erreurs.
Exemple dans Express :
import express, { Request, Response, NextFunction } from 'express';
const app = express();
app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
console.error('Error:', err.message);
res.status(500).json({ error: err.message });
});
Cette approche garantit que toutes les erreurs non gérées sont détectées et traitées de manière cohérente.
6. Utiliser des types utilitaires pour une sécurité accrue
Types d’utilitaires TypeScript comme Partiel, Prendre, et Lecture seule vous aider à définir des sous-ensembles spécifiques de structures d’erreur.
Explication:
Les types d’utilitaires vous permettent de vous concentrer sur les propriétés pertinentes d’un objet d’erreur, réduisant ainsi le passe-partout et améliorant la maintenabilité.
Exemple:
type ErrorResponse = Pick<CustomError, 'message' | 'statusCode'>;
function handleErrorResponse(error: ErrorResponse): void {
console.error(`Error (${error.statusCode}): ${error.message}`);
}
Ici, Prendre garantit que seules les propriétés nécessaires de Erreur personnalisée sont utilisés dans la logique de gestion des erreurs.
7. Intégrer des outils de surveillance des erreurs
Les outils de surveillance des erreurs tels que Sentry ou Rollbar fournissent des informations précieuses sur les erreurs d’application, vous aidant ainsi à déboguer et à améliorer la fiabilité.
Explication:
Les outils de surveillance capturent les erreurs d’exécution et fournissent des rapports détaillés, notamment les traces de pile, les sessions utilisateur et les détails de l’environnement.
Exemple avec Sentry :
import * as Sentry from '@sentry/node';
Sentry.init({ dsn: 'your-dsn' });
try {
// Risky operation
} catch (error) {
Sentry.captureException(error);
console.error('Error captured:', error);
}
Ces outils sont particulièrement utiles dans les environnements de production pour détecter et résoudre les problèmes de manière proactive.
Conclusion
La gestion des erreurs est la pierre angulaire de la fiabilité des applications. En exploitant les fonctionnalités de TypeScript telles que le typage statique, les types union et les classes d’erreur personnalisées, vous pouvez construire des systèmes qui gèrent les erreurs de manière élégante et qui maintiennent des normes élevées de qualité du code. L’adoption de ces bonnes pratiques ne rendra pas seulement vos applications plus robustes, mais améliorera également l’expérience globale du développeur.
