JavaScript - Custom Errors: A Beginner's Guide

Hallo zusammen, zukünftige JavaScript-Zauberer! Heute machen wir uns auf eine aufregende Reise in die Welt der benutzerdefinierten Fehler in JavaScript. Machen Sie sich keine Sorgen, wenn Sie neu im Programmieren sind – ich werde Ihr freundlicher Guide sein, der komplexe Konzepte in mundgerechte, leicht verdauliche Stücke zerlegt. Holen Sie sich Ihr lieblingsGetränk, machen Sie es sich bequem und Tauchen wir ein!

Die Error-Klasse: Dein neuer bester Freund

Bevor wir mit der Erstellung unserer eigenen benutzerdefinierten Fehler beginnen, lassen Sie uns uns mit der eingebauten Error-Klasse in JavaScript vertraut machen. Denken Sie daran als die Grundlage, auf der wir unser Meisterwerk der Fehlerbehandlung aufbauen werden.

Die Error-Klasse ist wie ein Template für die Erstellung von Fehlerobjekten. Wenn etwas in Ihrem Code schiefgeht, verwendet JavaScript diese Klasse, um Ihnen Informationen darüber zu geben, was passiert ist. Sehen wir uns ein einfaches Beispiel an:

try {
throw new Error("Ups! Etwas ist schiefgelaufen!");
} catch (error) {
console.log(error.message);
}

Wenn Sie diesen Code ausführen, werden Sie sehen:

Ups! Etwas ist schiefgelaufen!

So einfach war das! Die Error-Klasse gab uns eine Möglichkeit, Fehler in unserem Code zu erstellen und zu behandeln. Aber was ist, wenn wir spezifischere Arten von Fehler erstellen möchten? Das ist, wo benutzerdefinierte Fehler ins Spiel kommen!

Erstellung von benutzerdefinierten Fehlern mit einer Instanz der Error-Klasse

Nun, da wir die grundlegende Error-Klasse verstehen, lassen Sie uns unseren ersten benutzerdefinierten Fehler erstellen. Wir beginnen mit der einfachsten Methode: der Verwendung einer Instanz der Error-Klasse.

function divide(a, b) {
if (b === 0) {
throw new Error("DivisionByZeroError: Kann nicht durch null teilen!");
}
return a / b;
}

try {
console.log(divide(10, 0));
} catch (error) {
console.log(error.message);
}

In diesem Beispiel haben wir eine divide-Funktion erstellt, die einen benutzerdefinierten Fehler wirft, wenn jemand versucht, durch null zu teilen. Wenn wir diesen Code ausführen, werden wir sehen:

DivisionByZeroError: Kann nicht durch null teilen!

Diese Methode ist einfach und effektiv, aber sie ermöglicht es uns nicht, wirklich benutzerdefinierte Fehlerarten zu erstellen. Lassen Sie uns einige fortgeschrittenere Methoden erkunden!

Erstellung von benutzerdefinierten Fehlern mit dem Funktionskonstruktor

Eine andere Möglichkeit, benutzerdefinierte Fehler zu erstellen, ist die Verwendung eines Funktionsspielers. Diese Methode gibt uns mehr Flexibilität bei der Definition unserer Fehlerarten.

function CustomError(message) {
this.name = "CustomError";
this.message = message || "Ein benutzerdefinierter Fehler ist aufgetreten";
this.stack = (new Error()).stack;
}

CustomError.prototype = Object.create(Error.prototype);
CustomError.prototype.constructor = CustomError;

try {
throw new CustomError("Dies ist mein benutzerdefinierter Fehler!");
} catch (error) {
console.log(error.name + ": " + error.message);
}

Wenn wir diesen Code ausführen, werden wir sehen:

CustomError: Dies ist mein benutzerdefinierter Fehler!

Diese Methode ermöglicht es uns, eine neue Fehlerart mit eigenem Namen und Standardnachricht zu erstellen. Es ist, als ob wir eine ganze neue Art von Fehler geschaffen hätten!

Erstellung von benutzerdefinierten Fehlern durch Erweiterung der Error-Klasse

Für unseren letzten Trick verwenden wir die ES6-Klassenntax, um die Error-Klasse zu erweitern. Dies ist meine persönliche Lieblingsmethode, weil sie sauber, intuitiv und leistungsstark ist.

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

function validateUser(user) {
if (!user.username) {
throw new ValidationError("Benutzername ist erforderlich");
}
if (!user.email) {
throw new ValidationError("E-Mail ist erforderlich");
}
}

try {
validateUser({ username: "johndoe" });
} catch (error) {
if (error instanceof ValidationError) {
console.log(`${error.name}: ${error.message}`);
console.log(`Fehler ist aufgetreten am: ${error.date}`);
} else {
console.log("Ein unbekannter Fehler ist aufgetreten");
}
}

Wenn wir diesen Code ausführen, werden wir sehen:

ValidationError: E-Mail ist erforderlich
Fehler ist aufgetreten am: [aktuelles Datum und Uhrzeit]

Diese Methode ermöglicht es uns, komplexe benutzerdefinierte Fehler mit zusätzlichen Eigenschaften (wie date in diesem Beispiel) und Methoden, falls erforderlich, zu erstellen.

Zusammenfassung: Eine Tabelle der Methoden

Um die Methoden, die wir gelernt haben, zusammenzufassen, hier ist eine praktische Tabelle:

Methode	Vor- und Nachteile
Verwendung von Error-Instanz	Einfach, schnell umzusetzen
Funktionsspiel constructor	Flexibel, ermöglicht benutzerdefinierte Eigenschaften
Erweiterung der Error-Klasse	Saubere Syntax, volle Anpassungsmöglichkeiten

Denken Sie daran, es gibt keine eine für alle Lösungen. Die beste Methode hängt von Ihren spezifischen Bedürfnissen und der Komplexität Ihres Projekts ab.

Benutzerdefinierte Fehler sind wie geheime Waffen in Ihrer JavaScript-Ausrüstung. Sie helfen Ihnen, Probleme in Ihrem Code effektiver zu fangen und zu behandeln, machen Ihre Programme robuster und einfacher zu debuggen. Also auf in die Zukunft, junge Programmierer, und möge Ihre Fehler stets benutzerdefiniert und Ihre Fehlersuche flink sein!

Credits: Image by storyset