Chapitre 13 – Gestion des erreurs

Lorsqu'une erreur se produit en JavaScript, cela peut arrêter complètement l'exécution du script. Il est donc essentiel de savoir gérer ces erreurs pour assurer la stabilité et la robustesse de vos applications.

Zone de démonstration interactive

Les messages d'erreur apparaîtront ici

1. try, catch, finally

Le bloc try...catch vous permet de tester un morceau de code, d'intercepter les erreurs potentielles et d'agir en conséquence sans bloquer l'ensemble du programme.

try {
  // Code qui pourrait provoquer une erreur
  let resultat = 10 / 0;
  console.log("Résultat :", resultat);
} catch (erreur) {
  // Ce bloc est exécuté si une erreur se produit
  console.error("Une erreur est survenue :", erreur.message);
} finally {
  // Ce bloc est toujours exécuté, qu'il y ait une erreur ou non
  console.log("Bloc finally exécuté");
}

try : contient le code à exécuter.
catch : intercepte l'erreur si elle survient.
finally : exécuté systématiquement à la fin, pour nettoyer ou finaliser quelque chose.

function diviser(a, b) {
  try {
    if (b === 0) {
      throw new Error("Division par zéro interdite");
    }
    return a / b;
  } catch (err) {
    console.error("Erreur capturée :", err.message);
    return null;
  } finally {
    console.log("Fin de la tentative de division");
  }
}

diviser(10, 0);

2. Lancer une erreur avec throw

Vous pouvez créer et lancer vos propres erreurs avec le mot-clé throw. Cela est utile pour interrompre une exécution lorsqu'une condition anormale est détectée.

throw new Error("Ceci est une erreur personnalisée");

Exemple complet :

function calculerRacineCarree(x) {
  if (x < 0) {
    throw new RangeError("Impossible de calculer la racine carrée d'un nombre négatif");
  }
  return Math.sqrt(x);
}

try {
  console.log(calculerRacineCarree(-5));
} catch (e) {
  console.error("Erreur :", e.message);
}

Note : Vous pouvez lancer différents types d'erreurs : Error, TypeError, RangeError, etc.

3. Objets d'erreurs

Lorsqu'une erreur est capturée dans un catch, elle est représentée par un objet comportant plusieurs propriétés utiles :

name : le type d'erreur (Error, TypeError, ReferenceError...)
message : la description de l'erreur
stack : la pile d'appels (utile pour le débogage)

try {
  let utilisateur = undefined;
  console.log(utilisateur.nom);
} catch (err) {
  console.log("Nom de l'erreur :", err.name);
  console.log("Message :", err.message);
  console.log("Stack trace :", err.stack);
}

4. Erreurs personnalisées

Vous pouvez créer vos propres classes d'erreurs en héritant de Error pour structurer votre gestion d'erreurs.

class MonErreurPerso extends Error {
  constructor(message) {
    super(message);
    this.name = "MonErreurPerso";
    this.date = new Date();
  }
}

try {
  throw new MonErreurPerso("Ceci est une erreur personnalisée !");
} catch (e) {
  console.error(`${e.name} [${e.date}]: ${e.message}`);
}

Exemple d'erreur métier personnalisée

class ErreurValidation extends Error {
  constructor(champ, message) {
    super(message);
    this.name = "ErreurValidation";
    this.champ = champ;
    this.date = new Date();
  }
}

function validerUtilisateur(utilisateur) {
  if (!utilisateur.nom) {
    throw new ErreurValidation("nom", "Le nom est obligatoire");
  }
  if (utilisateur.age < 18) {
    throw new ErreurValidation("age", "L'âge doit être ≥ 18");
  }
}

try {
  validerUtilisateur({ age: 15 });
} catch (e) {
  if (e instanceof ErreurValidation) {
    console.error(`Erreur sur le champ ${e.champ}: ${e.message}`);
  } else {
    console.error("Erreur inattendue:", e);
  }
}

Résumé du chapitre

try...catch permet de tester du code et d'intercepter les erreurs sans faire planter le script.
finally est toujours exécuté, qu'il y ait une erreur ou non, pour effectuer du nettoyage ou afficher un message final.
Avec throw, vous pouvez déclencher manuellement des erreurs en fonction de vos propres conditions métier.
Les objets d'erreurs contiennent des informations comme le type (name), le message d'erreur, et la pile d'exécution (stack).
Créer des classes d'erreurs personnalisées peut améliorer la lisibilité et la maintenance de votre code.

Maîtriser la gestion des erreurs vous permettra d'écrire des programmes plus robustes et sécurisés, capables de mieux réagir aux imprévus.