OOP mit JavaScript - Fehlerbehandlung

1. Ein Hinweis vorab

Das was ich euch jetzt zeige, hat mit OOP eigentlich nichts zu tun. Aber das gilt ja für andere Themen aus diesem Bereich auch. Egal, es ist auf jeden Fall was für fortgeschrittene Anfänger, darum habe ich das hier hinein gepackt.

2. Das Prinzip

... ist ähnlich wie in PHP. Also versuchen, fangen, werfen. Allerdings gibt es bei JavaScript noch etwas, das in PHP immer noch fehlt, nämlich zu guter Letzt.

Ein Bespiel


try {
  if (!document.getElementById('bla')) {
    throw ('Is net da');
  }
  else { ... }
}
catch (e) {
  alert (e);
}
finally {
  alert ('hier');
}

Erläuterung

Im try-Block prüfen wir zunächst, ob ein HTML-Element mit der ID bla vorhanden ist. Wenn dem nicht so ist, so wird eine Exception geworfen. Die steht dann im catch-Block als Parameter zur Verfügung. In diesem Fall geben wir die im throw festgelegte Fehlermeldung aus.

Interessant ist hier das finally. Denn was in dem Block steht, wird auf jeden Fall ausgeführt. Noch ein Hinweis. Natürlich kann man im catch-Block auch noch mit weiteren Bedingungen arbeiten und die Fehlerbehandlung verfeinern.

3. Vorgegebene Fehlertypen

Neben eigenen definierten Fehlern bietet uns JavaScript auch noch interne an, die natürlich als Objekt angelegt sind. Als da wären.

EvalError greift, wenn bei eval ein Fehler auftritt
SyntaxError greift, wenn bei eval oder einem regulären Ausdrück ein Syntaxfehler vorhanden ist
RangeError greift, wenn eine numerische Variable oder ein Parameter außerhalb des Gültigkeitsbereichs liegt
TypeError greift, wenn eine Variable oder ein Parameter nicht valide ist
ReferenceError greift, wenn beim Zugriff auf eine Variable oder Funktion selbige nicht vorhanden ist

Eigenschaften

Davon gibt es eigentlich eine ganze Menge, Allerdings ist die Implementierung bei den einzelnen Browsern so unterschiedlich, dass man eigentlich nur zwei davon benutzen kann.

name Name des Fehlers
message die Fehlermeldung

Und diese Fehlertypen kann man nun mit instanceof abfangen.

Ein Beispiel


try {
  bla.blubb();
} 
catch (e) {
  if (e instanceof EvalError) {
    alert(e.name + ':' + e.message);
  } 
  else if (e instanceof RangeError) {
    alert(e.name + ':' + e.message);
  }
  else if (e instanceof TypeError) {
    alert(e.name + ':' + e.message);
  }
  else if (e instanceof ReferenceError) {
    alert(e.name + ':' + e.message);
  }
}

Erläuterung

In diesem Beispiel wird im catch-Block nach Fehlertypen unterschieden und dann der Name und die Meldung ausgegeben. Aber vorsichtig! Normale Browser werfen hier einen ReferenceError. Nur der Internet Explorer tanzt mal wieder aus der Reihe und haut uns einen TypeError um die Ohren.

3. Eigene Fehler definieren

Auch das ist in JavaScript möglich und zwar über das Error-Objekt. Allerdings sind die Möglichkeiten arg beschränkt. Oder genauer gesagt, man kann nur Fehlermeldungen erzeugen.


try {
  if (document.getElementById('bla')) {
  
  }
  else {
    throw (new Error('Riesen Schei***e'));
  }
}
catch(e) {
  alert(e.message);
}

Wie ihr schon seht, gibt es zum ersten Beispiel praktisch gesehen keinen Unterschied. Der ist nur theoretischer Natur. Denn hier haben wir ein Error-Objekt erzeugt. Mehr nicht. name hat als Wert Error und message unseren String. Interessant wird es dagegen, wenn man selber interne Abstufungen der eigenen Fehler vornehmen möchte.


try {
  if (...) { 
    ...
  }
  else {
    if (...) {
      e1 = new Error('Nicht so wild');
      throw (e1);
    }
    else {
      e2 = new Error('Riesen Schei***e');
      throw (e2);
    }    
  }
}
catch(e1) {
  // Weitermachen
}
catch(e2) {
  // Alle Maschinen voller Stop
}

4. Ein kleines Fazit am Ende

Ich hoffe, ihr habt meinen Ausführungen folgen können. Denn OOP mit JavaScript ist ganz schön kompliziert. Vor allem, wenn man sonst mit anderen Sprachen zu tun hat. Und passt höllisch auf, was euch andere so erzählen. Oder was ihr so im Internet zu diesem Thema findet. Denn da geben viele einen ziemlichen Schrott von sich. Ich selber bin da auch schon zweimal darauf reingefallen.

Eine Ergänzung

Auf einige Möglichkeiten bin ich bisher nicht eingegangen, weil mir deren Konzepte nicht so wahnsinnig toll gefallen. Trotzdem werde ich demnächst ein Ergänzungstutorial dazu verfassen, wo ich mich besonders auf Literale und die ominösen anonymem Variablenfunktionen/benannte Funktionsausdrücke konzentrieren werde.

zurück zum vorherigen Abschnitt