Apprendre à gérer des erreurs

La gestion des erreurs est un aspect crucial du développement logiciel. En Node.js, les erreurs peuvent être gérées de manière synchrone avec des blocs try/catch et de manière asynchrone avec des callbacks, des promesses, et async/await. Voici comment vous pouvez gérer les erreurs dans différents contextes :

Gestion des Erreurs dans les Callbacks

Dans les fonctions de rappel (callbacks), les erreurs sont généralement passées comme premier argument selon la convention de Node.js (err, result).

fs.readFile('/chemin/vers/le/fichier.txt', 'utf8', (err, data) => {
  if (err) {
    // Gérer l'erreur ici
    console.error(err);
    return;
  }
  // Utiliser les données
  console.log(data);
});

Gestion des Erreurs avec les Promesses

Les promesses ont des méthodes .then() pour le succès et .catch() pour les erreurs.

fs.promises.readFile('/chemin/vers/le/fichier.txt', 'utf8')
  .then(data => {
    // Utiliser les données
    console.log(data);
  })
  .catch(err => {
    // Gérer l'erreur ici
    console.error(err);
  });

Avec async/await, vous pouvez utiliser des blocs try/catch pour gérer les erreurs de manière synchrone tout en écrivant du code asynchrone.

async function lireFichier(chemin) {
  try {
    const data = await fs.promises.readFile(chemin, 'utf8');
    console.log(data);
  } catch (err) {
    // Gérer l'erreur ici
    console.error(err);
  }
}

lireFichier('/chemin/vers/le/fichier.txt');

Avec les streams, vous devez écouter les événements d'erreur.

const stream = fs.createReadStream('/chemin/vers/le/fichier.txt');

stream.on('data', (data) => {
  // Utiliser les données
  console.log(data);
});

stream.on('error', (err) => {
  // Gérer l'erreur ici
  console.error(err);
});

Les erreurs peuvent également être émises par des émetteurs d'événements. Vous devez écouter les événements d'erreur pour les gérer.

const emitter = new events.EventEmitter();

emitter.on('error', (err) => {
  // Gérer l'erreur ici
  console.error('Erreur capturée', err);
});

emitter.emit('error', new Error('Quelque chose a mal tourné'));

• Ne jamais ignorer les erreurs : Même si vous pensez qu'une erreur ne peut pas se produire, ajoutez toujours une logique de gestion des erreurs.
• Propager les erreurs : Dans les callbacks, si vous êtes dans une fonction imbriquée, propagez les erreurs au callback parent.
• Utiliser des erreurs standardisées : Utilisez des instances de Error ou des sous-classes pour que les gestionnaires d'erreurs puissent identifier et réagir correctement aux types d'erreurs.
• Enrichir les erreurs : Ajoutez des informations supplémentaires aux objets d'erreur pour faciliter le débogage (par exemple, des codes d'erreur personnalisés).
• Gestion centralisée des erreurs : Envisagez d'utiliser un mécanisme centralisé pour la gestion des erreurs, surtout pour les applications plus grandes.
• Journalisation des erreurs : Enregistrez les erreurs dans un fichier de log ou un système de gestion des logs pour une analyse ultérieure.
• Gestion des exceptions non capturées : Écoutez process.on('uncaughtException') pour les erreurs non capturées, mais utilisez-le avec prudence et assurez-vous de terminer le processus après une telle erreur.

La gestion des erreurs est un élément essentiel pour créer des applications robustes et fiables. Prenez le temps de réfléchir à la manière dont votre application doit réagir en présence d'erreurs pour assurer une bonne expérience utilisateur et faciliter la maintenance du code.