JavaScript - Étendre les erreurs

Bonjour, futurs magiciens JavaScript ! Aujourd'hui, nous allons plonger dans le monde passionnant de l'extension des erreurs en JavaScript. Ne vous inquiétez pas si vous êtes nouveau dans la programmation - je serai votre guide amical à travers cette aventure. D'ici la fin de cette leçon, vous créerez vos propres erreurs personnalisées comme un pro !

Étendre la classe Error : Créer des erreurs personnalisées

Commençons par les bases. En JavaScript, nous avons une classe Error intégrée que nous pouvons utiliser pour créer des objets d'erreur. Mais parfois, nous avons besoin d'erreurs plus spécifiques pour nos applications. C'est là que l'extension de la classe Error devient pratique !

Pourquoi étendre les erreurs ?

Imaginez que vous construisez une application de cuisine, et que vous souhaitez créer des erreurs spécifiques pour les incidents de cuisine. Vous pourriez utiliser l'erreur générique, mais ne serait-il pas mieux d'avoir un BurnedFoodError ou un OverseasonedError ? C'est ce que nous allons apprendre à faire !

Syntaxe de base pour étendre les erreurs

Commençons par un exemple simple :

class KitchenError extends Error {
constructor(message) {
super(message);
this.name = 'KitchenError';
}
}

Décomposons cela :

1. Nous utilisons le mot-clé class pour définir notre nouvelle classe d'erreur.
2. extends Error indique à JavaScript que notre nouvelle classe doit hériter de la classe Error intégrée.
3. Dans le constructor, nous appelons super(message) pour nous assurer que la classe parent Error est correctement initialisée.
4. Nous définissons this.name pour donner à notre erreur un nom spécifique.

Voici comment nous pouvons l'utiliser :

try {
throw new KitchenError("Les spaghettis sont collés au plafond !");
} catch (error) {
console.log(error.name); // Affiche : KitchenError
console.log(error.message); // Affiche : Les spaghettis sont collés au plafond !
}

Ajouter des propriétés personnalisées

Une des choses les plus géniales à propos de l'extension des erreurs est que nous pouvons ajouter nos propres propriétés personnalisées. Améliorons notre KitchenError :

class KitchenError extends Error {
constructor(message, dish) {
super(message);
this.name = 'KitchenError';
this.dish = dish;
}
}

try {
throw new KitchenError("Ça brûle !", "lasagne");
} catch (error) {
console.log(`Oh non ! La ${error.dish} est en difficulté : ${error.message}`);
// Affiche : Oh non ! La lasagne est en difficulté : Ça brûle !
}

Dans cet exemple, nous avons ajouté une propriété dish à notre erreur. Cela nous permet de fournir plus de contexte sur ce qui s'est mal passé dans notre désastre culinaire !

Créer des types d'erreur spécifiques

Maintenant que nous savons comment étendre la classe Error, créons quelques types d'erreur spécifiques pour notre application de cuisine :

class BurnedFoodError extends KitchenError {
constructor(dish) {
super(`La ${dish} est brûlée jusqu'à la croustillante !`, dish);
this.name = 'BurnedFoodError';
}
}

class OverseasonedError extends KitchenError {
constructor(dish, seasoning) {
super(`La ${dish} est trop assaisonnée avec ${seasoning} !`, dish);
this.name = 'OverseasonedError';
this.seasoning = seasoning;
}
}

Maintenant, nous pouvons utiliser ces types d'erreur spécifiques dans notre code :

function cookDinner(dish, seasoning) {
if (Math.random() < 0.5) {
throw new BurnedFoodError(dish);
} else if (Math.random() < 0.5) {
throw new OverseasonedError(dish, seasoning);
}
console.log(`Votre ${dish} est parfaitement cuit !`);
}

try {
cookDinner("steak", "sel");
} catch (error) {
if (error instanceof BurnedFoodError) {
console.log(`Oups ! ${error.message} Il est temps de commander à emporter.`);
} else if (error instanceof OverseasonedError) {
console.log(`Oh là là ! ${error.message} Peut-être utiliser moins de ${error.seasoning} la prochaine fois.`);
} else {
console.log("Quelque chose s'est mal passé dans la cuisine !");
}
}

Ce code simule la nature imprévisible de la cuisine (au moins pour certains d'entre nous !) et montre comment nous pouvons gérer différents types d'erreurs de différentes manières.

Héritage multination

Maintenant, transportons notre hiérarchie d'erreurs au niveau supérieur - littéralement ! Nous pouvons créer une chaîne de types d'erreur, chacun héritant du précédent. Cela s'appelle l'héritage multination.

Élargissons notre système d'erreur de cuisine :

class KitchenApplianceError extends KitchenError {
constructor(message, appliance) {
super(message);
this.name = 'KitchenApplianceError';
this.appliance = appliance;
}
}

class OvenError extends KitchenApplianceError {
constructor(message) {
super(message, 'four');
this.name = 'OvenError';
}
}

class MicrowaveError extends KitchenApplianceError {
constructor(message) {
super(message, 'micro-ondes');
this.name = 'MicrowaveError';
}
}

Dans cet exemple :

• KitchenApplianceError étend KitchenError
• OvenError et MicrowaveError héritent tous deux de KitchenApplianceError

Voici comment nous pouvons utiliser cette hiérarchie :

function useAppliance(appliance) {
if (appliance === 'four') {
throw new OvenError("Le four ne chauffe pas !");
} else if (appliance === 'micro-ondes') {
throw new MicrowaveError("Le micro-ondes fait du bruit bizarre !");
}
}

try {
useAppliance('four');
} catch (error) {
if (error instanceof OvenError) {
console.log(`Problème de four : ${error.message}`);
} else if (error instanceof MicrowaveError) {
console.log(`Problème de micro-ondes : ${error.message}`);
} else if (error instanceof KitchenApplianceError) {
console.log(`Erreur générale d'appareil de cuisine avec le ${error.appliance} : ${error.message}`);
} else if (error instanceof KitchenError) {
console.log(`Erreur de cuisine : ${error.message}`);
} else {
console.log(`Erreur inattendue : ${error.message}`);
}
}

Cet héritage multination nous permet de créer des types d'erreur très spécifiques tout en maintenant une hiérarchie logique. Nous pouvons attraper des erreurs à différents niveaux de spécificité, de la plus spécifique (OvenError) à la plus générale (Error).

Tableau des méthodes

Voici un tableau résumant les méthodes et propriétés clés que nous avons utilisées dans nos erreurs personnalisées :

Méthode/Propriété	Description	Exemple
constructor()	Initialise l'objet d'erreur	constructor(message, dish)
super()	Appelle le constructeur de la classe parent	super(message)
this.name	Définit le nom de l'erreur	this.name = 'KitchenError'
this.[custom]	Ajoute une propriété personnalisée	this.dish = dish
instanceof	Vérifie si un objet est une instance d'une classe	if (error instanceof OvenError)

Souvenez-vous, étendre les erreurs ne consiste pas seulement à créer des noms fancy pour vos erreurs - c'est à propos de créer une manière structurée de gérer différents types d'erreurs dans votre code. Cela peut rendre le débogage plus facile et vos messages d'erreur plus informatifs et spécifiques.

Donc, la prochaine fois que vous codez et que quelque chose ne va pas, ne jetez pas une erreur générique - créez-en une personnalisée ! Qui sait, peut-être que votre CodeSpaghettiError deviendra la vedette de votre équipe de développement. Bonne programmation, et que toutes vos erreurs soient parfaitement étendues !

Credits: Image by storyset