JavaScript - Erweiterung von Fehlerklassen

Hallo, zukünftige JavaScript-Zauberer! Heute tauchen wir ein in die aufregende Welt der Fehlererweiterungen in JavaScript. Keine Sorge, wenn du neu im Programmieren bist – ich werde dein freundlicher Guide durch dieses Abenteuer sein. Am Ende dieser Lektion wirst du in der Lage sein, deine eigenen benutzerdefinierten Fehler wie ein Profi zu erstellen!

Erweiterung der Fehlerklasse: Erstellung von benutzerdefinierten Fehlern

Lassen wir mit den Grundlagen beginnen. In JavaScript haben wir eine integrierte Error-Klasse, die wir verwenden können, um Fehlerobjekte zu erstellen. Aber manchmal benötigen wir für unsere Anwendungen spezifischere Fehler. Da kommt die Erweiterung der Error-Klasse gerade recht!

Warum Fehler erweitern?

Stellen wir uns vor, du baust eine Koch-App, und du möchtest spezifische Fehler für Küchenunfälle erstellen. Du könntest den allgemeinen Error verwenden, aber wäre es nicht schöner, einen BurnedFoodError oder OverseasonedError zu haben? Genau das werden wir lernen!

Grundlegende Syntax zur Erweiterung von Fehlern

Lassen wir mit einem einfachen Beispiel beginnen:

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

Lassen wir das auseinandernehmen:

1. Wir verwenden das class-Schlüsselwort, um unsere neue Fehlerklasse zu definieren.
2. extends Errorweist JavaScript an, dass unsere neue Klasse von der integrierten Error-Klasse ableiten soll.
3. Im constructor rufen wir super(message) auf, um sicherzustellen, dass die übergeordnete Error-Klasse ordnungsgemäß initialisiert wird.
4. Wir setzen this.name, um unserem Fehler einen bestimmten Namen zu geben.

Nun sehen wir, wie wir das verwenden können:

try {
throw new KitchenError("Die Spaghetti klebt an der Decke!");
} catch (error) {
console.log(error.name); // Ausgabe: KitchenError
console.log(error.message); // Ausgabe: Die Spaghetti klebt an der Decke!
}

Hinzufügen benutzerdefinierter Eigenschaften

Eine der coolsten Sachen bei der Erweiterung von Fehlern ist, dass wir unsere eigenen benutzerdefinierten Eigenschaften hinzufügen können. Lassen wir unseren KitchenError besser machen:

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

try {
throw new KitchenError("Es brennt!", "Lasagne");
} catch (error) {
console.log(`Oh nein! Die ${error.dish} ist in Gefahr: ${error.message}`);
// Ausgabe: Oh nein! Die Lasagne ist in Gefahr: Es brennt!
}

In diesem Beispiel haben wir eine dish-Eigenschaft zu unserem Fehler hinzugefügt. Dies ermöglicht es uns, mehr Kontext über unseren Küchenunfall zu geben!

Erstellung spezifischer Fehlerarten

Nun, da wir wissen, wie man die Error-Klasse erweitert, erstellen wir einige spezifische Fehlerarten für unsere Küchen-App:

class BurnedFoodError extends KitchenError {
constructor(dish) {
super(`Das ${dish} ist verkohlt!`, dish);
this.name = 'BurnedFoodError';
}
}

class OverseasonedError extends KitchenError {
constructor(dish, seasoning) {
super(`Das ${dish} ist zu stark gewürzt mit ${seasoning}!`, dish);
this.name = 'OverseasonedError';
this.seasoning = seasoning;
}
}

Nun können wir diese spezifischen Fehlerarten in unserem Code verwenden:

function kochen(dish, seasoning) {
if (Math.random() < 0.5) {
throw new BurnedFoodError(dish);
} else if (Math.random() < 0.5) {
throw new OverseasonedError(dish, seasoning);
}
console.log(`Dein ${dish} ist perfekt zubereitet!`);
}

try {
kochen("Steak", "Salz");
} catch (error) {
if (error instanceof BurnedFoodError) {
console.log(`Ups! ${error.message} Zeit, Essenslieferung zu bestellen.`);
} else if (error instanceof OverseasonedError) {
console.log(`Oh je! ${error.message} Vielleicht weniger ${error.seasoning} nächstes Mal verwenden.`);
} else {
console.log("Etwas ist in der Küche schiefgelaufen!");
}
}

Dieser Code simuliert die unvorhersehbare Natur des Kochens (mindestens für einige von uns!) und zeigt, wie wir verschiedene Fehlerarten auf verschiedene Weisen behandeln können.

Mehrstufige Vererbung

Nun, nehmen wir unsere Fehlerhierarchie auf die nächste Stufe – wortwörtlich! Wir können eine Kette von Fehlerarten erstellen, die jeweils von der vorherigen ableiten. Dies wird als mehrstufige Vererbung bezeichnet.

Lassen wir unser Küchenfehler-System erweitern:

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

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

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

In diesem Beispiel:

• KitchenApplianceError erweitert KitchenError
• OvenError und MicrowaveError erweitern KitchenApplianceError

Sehen wir uns an, wie wir diese Hierarchie verwenden können:

function gerätVerwenden(gerät) {
if (gerät === 'ofen') {
throw new OvenError("Der Ofen heizt nicht auf!");
} else if (gerät === 'mikrowelle') {
throw new MicrowaveError("Die Mikrowelle macht komische Geräusche!");
}
}

try {
gerätVerwenden('ofen');
} catch (error) {
if (error instanceof OvenError) {
console.log(`Ofenproblem: ${error.message}`);
} else if (error instanceof MicrowaveError) {
console.log(`Mikrowellenproblem: ${error.message}`);
} else if (error instanceof KitchenApplianceError) {
console.log(`Allgemeiner Gerätefehler mit der ${error.appliance}: ${error.message}`);
} else if (error instanceof KitchenError) {
console.log(`Küchenfehler: ${error.message}`);
} else {
console.log(`Unerwarteter Fehler: ${error.message}`);
}
}

Diese mehrstufige Vererbung ermöglicht es uns, sehr spezifische Fehlerarten zu erstellen, während wir eine logische Hierarchie beibehalten. Wir können Fehler auf verschiedenen Stufen der Spezifität abfangen, von den spezifischsten (OvenError) bis zu den allgemeinsten (Error).

Methodenübersicht

Hier ist eine Tabelle, die die wichtigsten Methoden und Eigenschaften zusammenfasst, die wir in unseren benutzerdefinierten Fehlern verwendet haben:

Methode/Eigenschaft	Beschreibung	Beispiel
constructor()	Initialisiert das Fehlerobjekt	constructor(message, dish)
super()	Ruft den Konstruktor der übergeordneten Klasse auf	super(message)
this.name	Setzt den Namen des Fehlers	this.name = 'KitchenError'
this.[custom]	Fügt eine benutzerdefinierte Eigenschaft hinzu	this.dish = dish
instanceof	Überprüft, ob ein Objekt eine Instanz einer Klasse ist	if (error instanceof OvenError)

Denke daran, dass das Erweitern von Fehlern nicht nur darum geht, schicke Namen für deine Fehler zu erstellen – es geht darum, eine strukturierte Methode zur Behandlung verschiedener Fehlerarten in deinem Code zu schaffen. Dies kann das Debuggen erleichtern und deine Fehlermeldungen informativer und spezifischer machen.

Also, wenn du das nächste Mal codest und etwas schiefgeht, wirf nicht einfach einen allgemeinen Fehler aus – erstelle einen benutzerdefinierten! Wer weiß, vielleicht wird dein CodeSpaghettiError zum Gesprächsthema in deinem Entwicklungsteam. Viel Spaß beim Coden und möge alle deine Fehler perfekt erweitert sein!

Credits: Image by storyset