JavaScript von Christian Wenz
Browserübergreifende Lösungen

	Kapitel 23 Fehler
		23.1 Fehler abfangen
		23.2 JavaScript Debugger
		23.3 Fragen

Kapitel 23 Fehler

Unsere Probleme sind von Menschen gemacht, darum können sie auch von Menschen gelöst werden
– John F. Kennedy

Motivation

Fehlermeldungen sind der größte Feind eines Programmierers. Versierte Anwender wissen, worum es sich handelt, und der Nimbus der Unfehlbarkeit ist weg. Nicht ganz so gut informierte Benutzer jedoch wissen gar nicht, wie ihnen geschieht, wenn beispielsweise der Internet Explorer ein Warndreieck zeigt, und eventuell noch eine (nichts sagende – wie immer beim IE) Fehlermeldung.

Im Optimalfall treten Fehlermeldungen gar nicht auf, weil jede Eventualität berücksichtigt worden ist und die Programmierung perfekt ist. Das ist jedoch selbst bei kleineren Programmierprojekten eine Illusion und im Web erst recht. Selbst, wenn Sie keinen Fehler bei der Programmierung gemacht haben, es wird immer eine bestimmte Browserversion unter einem bestimmten Betriebssystem geben, die Ihnen einen Strich durch die Rechnung macht und unter bestimmten Umständen eine Fehlermeldung produziert.

Fehlermeldungen abfangen

Seit JavaScript-Version 1.2 gibt es jedoch Möglichkeiten, solche so genannten syntaktischen Fehler (Verstöße gegen die JavaScript-Syntaxregeln) abzufangen, sodass der Benutzer dadurch wenigstens nicht mehr belästigt wird, oder die Fehlermeldung besonders aufbereitet wird. Denn wenn der Benutzer schon auf einen Fehler stößt, dann ist es nur zu Ihrem Vorteil, wenn auch Sie davon erfahren!

Es gibt jedoch auch logische Fehler. Das sind Fehler, die zu keiner Fehlermeldung führen, aber dafür sorgen, dass das Skript ein falsches Ergebnis liefert. Diese Fehler sind erfahrungsgemäß am schwierigsten zu finden, eben weil der Fehler nur am Ergebnis sichtbar ist. Wenn Sie den Netscape Navigator einsetzen – was in Bezug auf Aussagekraft der Fehlermeldungen ohnehin vorteilhaft ist – können Sie mit einem kostenlosen Tool von Netscape dem Fehlerteufel auf die Spur kommen. Der JavaScript Debugger lässt Sie während der Ausführung eines Skripts auf die Werte der Variablen zugreifen, und Sie können den Skriptablauf auch unterbrechen.

23.1 Fehler abfangen

Im Bereich Event-Handler (siehe Kapitel 15) wurde auch kurz onError vorgestellt, der beim Eintreten eines Fehlers aktiv wird. Der Internet Explorer akzeptiert diesen Event-Handler bei praktisch jedem Objekt; der Netscape Navigator akzeptiert dies nur im <BODY>-Tag. Es gibt drei Möglichkeiten, diesen Event-Handler einzusetzen:

<BODY onError="Code"> – Führt beim Auftreten eines Fehlers den angegebenen Code aus

window.onerror = Funktionsreferenz – Führt die angegebene Funktion beim Auftreten eines Fehlers aus. Es muss eine Referenz auf die Funktion angegeben werden, also window.onerror = funktion und nicht window.onerror = funktion().

Nur unter Netscape zuverlässig: Eine Funktion namens onerror() wird definiert und dann automatisch ausgeführt, sobald ein Fehler auftritt.

23.1.1 Keine Fehlermeldung

Keine Fehlermeldung

Wenn die Funktion, die beim Auftreten eines Fehlers ausgeführt werden soll, oder allgemein der Code, der dann zur Ausführung kommt, mit return true endet, wird der Fehler nicht angezeigt, und der Benutzer bleibt unbehelligt.

Dies soll an einem Beispiel kurz demonstriert werden. Normalerweise würde die folgende Anweisung zu einer Fehlermeldung führen, die Variable rei ist nicht definiert. Da es jedoch eine Funktion onerror() gibt, die (immer) den Wert true zurückliefert, wird dieser Fehler verschluckt und nicht ausgegeben:

<HTML>
<HEAD>
<TITLE>Fehler abfangen</TITLE>
<SCRIPT LANGUAGE="JavaScript"><!--
function oe(){
   return true
}
window.onerror = oe
var panta = rei
//--></SCRIPT>
</HEAD>
<BODY>
Na, wo ist der Fehler?
</BODY>
</HTML>

Bug im Internet Explorer 5

Früher, in den guten Zeiten, war es noch möglich, mit window.onerror =null Fehlermeldungen zu deaktivieren. Einige Versionen des Internet Explorer 5 gehen jedoch beflissentlich darüber hinweg (der Internet Explorer 5 »übersieht« ja manchmal auch eine onerror()-Funktion).

23.1.2 Besondere Fehlermeldung

Details der
Fehlermeldung

Wie bereits eingangs erwähnt, kann man auch eine besondere Fehlermeldung ausgeben. An die Fehlerbehandlungsfunktion werden nämlich drei Parameter übergeben: Die Fehlermeldung, die URL des Dokuments, in dem der Fehler auftrat, und die Zeile, in der das fehlerhafte Kommando steht. Mit der folgenden Strategie können Sie also eine angepasste Fehlermeldung ausgeben:

Zeigen Sie eine etwas »freundlichere« Fehlermeldung für Ihre Nutzer an.

Beenden Sie die Funktion mit return true, damit der Browser danach die Fehlermeldung nicht anzeigt.

Der folgende Code zeigt dies einmal exemplarisch. Der Fehler wird mittels window.alert() ausgegeben, natürlich mit einem beruhigenden Hinweis.

<HTML>
<HEAD>
<TITLE>Fehler abfangen</TITLE>
<SCRIPT LANGUAGE="JavaScript"><!--
function oe(meldung, url, zeile){
   var txt = "Es ist ein Fehler aufgetreten! Das macht aber
     nichts...\n\n"
   txt += "Meldung: " + meldung + "\n"
   txt += "URL: " + url + "\n"
   txt += "Zeile: " + zeile
   alert(txt)
   return true
}
window.onerror = oe
var panta = rei
//--></SCRIPT>
</HEAD>
<BODY>
Na, wo ist der Fehler?
</BODY>
</HTML>

Abbildung 23.1 Die handgemachte Fehlermeldung

23.1.3 Ausblick: Fehlermeldungen verschicken

Obwohl es sich bei diesem Buch um ein JavaScript-Buch handelt, ist ein Blick über den Tellerrand nicht schlecht. Am günstigsten wäre es doch, wenn eine JavaScript-Fehlermeldung dem Surfer nicht angezeigt wird, aber automatisch via E-Mail an den Autor der Seite (also an Sie) versandt wird.

Ein erster Ansatz ist ziemlich umständlich, und nicht gerade professionell:

Öffnen Sie beim Auftreten einer Fehlermeldung mit window.open() ein neues Fenster.

Erstellen Sie mittels (vielen) document.write()-Anweisungen in dem neuen Fenster ein Formular, in dem Sie (z. B.) als versteckte Formularfelder die interessanten Daten eintragen: Fehlermeldung, URL und Zeile.

Setzen Sie das ACTION-Attribut des Formulars auf mailto:Ihre E–Mail@Ihr-Provider.de.

Fügen Sie an geeigneter Stelle in das Formular ein Kommando zum Versand des Formularsein:

setTimeout("document.forms[0].submit(); window.close", 1000)

Das Formular wird nun automatisch via E-Mail versandt, und das neu erschaffene Browserfenster gleich wieder geschlossen.

Der Haken

Toller Trick – aber er hat zwei Haken. Ich habe an anderer Stelle schon darauf hingewiesen, was von ACTION="mailto:..." in Formularen zu halten ist, und der Besucher Ihrer Website wird auch nicht gerade erfreut sein, wenn ungefragt über sein Konto eine E-Mail an Sie versandt wird. Hauptmanko ist jedoch, dass aus Sicherheitsgründen bei den meisten Browsern Formular.submit() nicht funktioniert, wenn ACTION auf mailto:... lautet. Aus diesem Grund finden Sie an dieser Stelle kein komplettes Skript, sondern dürfen sich in einer Übungsaufgabe damit herumschlagen.

Mit serverseitigen Mitteln ist das dagegen kein größeres Problem. Der Mail-Versand läuft auf Ihrem Webserver ab, der Benutzer bekommt (kaum) etwas mit. Es gibt hier elegante und weniger elegante Lösungen, und Sie sehen an dieser Stelle einen Mittelweg, der auf der Grundidee des vorherigen Ansatzes aufbaut. Es wird ein neues Fenster geöffnet, in diesem Fenster wird jedoch ein serverseitiges Skript aufgerufen, das die E–Mail versendet und dann das Fenster wieder schließt.

Welche Programmiersprache?

Das Hauptproblem: Welche serverseitige Programmiersprache wird eingesetzt? Ich habe mich hier für Perl und PHP entschieden. Erstere ist eine lang bewährte Sprache, die aber mehr und mehr an Boden gegenüber jüngeren und einfacher zu erlernende Konkurrenten verliert, wie beispielsweise ASP und eben PHP (die zweite verwendete Sprache). Doch die meisten Webserver unterstützen Perl (vor allem die meisten Hoster). Das Skript lässt sich mit relativ wenig Aufwand in andere Sprachen umschreiben, und bei MyGalileo finden Sie ein paar Beispiele. Es lohnt sich also, das Buch unter http://www.galileo-press.de zu registrieren!

Zunächst der HTML- und JavaScript-Code. Beim Auftreten eines Fehlers wird ein neues Fenster geöffnet. In der URL werden die Fehlerdaten (wie gewohnt: Meldung, URL, Zeile) übergeben. In Kapitel 12, »Formulare II«, haben Sie ja schon gesehen, wie Sie Daten in der Kommandozeile übergeben können. Von besonderer Bedeutung ist noch der Dateiname des serverseitigen Skripts. Perl-Programme liegen meistens im Verzeichnis /cgi-bin, und haben die Endung .pl oder .cgi.

Sie können dieses Skript nur testen, wenn Sie Ihren Webserver entsprechend konfiguriert haben, worauf an dieser Stelle aus Platzgründen nicht eingegangen werden kann. Wenn Sie ein Webangebot bei einem Hoster unterhalten, erhalten Sie dort weitere Hinweise.

<HTML>
<HEAD>
<TITLE>Fehler abfangen</TITLE>
<SCRIPT LANGUAGE="JavaScript"><!--
function oe(meldung, url, zeile){
   var perl = "/cgi-bin/fehler.pl?"
   perl += "meldung=" + escape(meldung)  //escape() nicht vergessen!
   perl += "&url=" + escape(url)
   perl += "&zeile=" + escape(zeile)
   window.open(perl, "Fehler", "width=100,height=100")
   return true
}
window.onerror = oe
var panta = rei
//--></SCRIPT>
</HEAD>
<BODY>
Na, wo ist der Fehler?
</BODY>
</HTML>

Nun zur Datei fehler.pl. Dieses Skript muss die folgenden Aufgaben erledigen:

Die Daten aus der URL auslesen

Diese Daten per E-Mail verschicken

Ein HTML-Dokument ausgeben, das im Wesentlichen dafür sorgt, dass das Fenster wieder geschlossen wird

Das folgende Perl-Programm erledigt all diese Aufgaben. Sie müssen das Programm gegebenenfalls an Ihre Verhältnisse anpassen. Wenn Sie UNIX oder Linux einsetzen, müssen Sie in der ersten Zeile den kompletten Pfad zu Ihrem Perl-Interpreter angeben (ist normalerweise /usr/bin/perl, aber manchmal auch /usr/local/bin/perl oder Ähnliches). Das Programm Sendmail, das für den Versand der E-Mail sorgt, liegt in der Regel auch im Verzeichnis /usr/bin, aber auch dies kann sich ändern. Sie können auch den Hauptkonkurrenten von Sendmail, qmail, einsetzen.

#!/usr/bin/perl
$fehler = $ENV'QUERY_STRING';
@namevalue = split(/&/, $fehler);
foreach $i (@namevalue){
   $i =~ tr/+/ /;
   $i =~ s/%(..)/pack("C", hex($1))/eg;
   ($name, $value) = split(/=/, $i);
   $fehler{$name} = $value;
}
open(SENDMAIL, "|/usr/bin/sendmail -t");
print(SENDMAIL "From: betatester\@website.de\n");
print(SENDMAIL "To: bugfixer\@website.de\n");
print(SENDMAIL "Subject: JavaScript-Fehler!\n\n");
print(SENDMAIL "Fehlermeldung: ".$fehler{'meldung'}."\n");
print(SENDMAIL "URL: ".$fehler{'url'}."\n");
print(SENDMAIL "Zeile: ".$fehler{'zeile'}."\n");
close(SENDMAIL);
print <<'EOF';
<HTML>
<HEAD>
<TITLE>Fehler entdeckt!</TITLE>
<SCRIPT LANGUAGE="JavaScript"><!--
window.close()
//--></SCRIPT>
</HEAD>
<BODY>Moment bitte ...</BODY>
</HTML>
EOF

Tritt nun ein JavaScript-Fehler auf, so öffnet sich für kurze Zeit das neue Browserfenster, eine E-Mail wird versandt, und das Fenster wird wieder geschlossen. So einfach ist das (mehr oder weniger)!

Die PHP-Version sieht in etwa wie Folgt aus:

<?php
$mailtext  = "Fehlermeldung: $meldung\n";
$mailtext .= "URL: $url\n";
$mailtext .= "Zeile: $zeile\n";
mail("bugfixer@website.de", "JavaScript-Fehler!", $mailtext, "");
?>
<HTML>
<HEAD>
<TITLE>Fehler entdeckt!</TITLE>
<SCRIPT LANGUAGE="JavaScript"><!--
  window.close()
//--></SCRIPT>
</HEAD>
<BODY>Moment bitte ...</BODY>
</HTML>

Die Datei muss die Endung .php haben, und der Webserver muss natürlich für die Unterstützung von PHP korrekt konfiguriert sein!

23.2 JavaScript Debugger

Unter http://developer.netscape.com/software/jsdebug.html stellt Netscape einen kostenlosen Debugger für JavaScript-Programme zur Verfügung. Dieser bietet die Basiseigenschaften eines Debuggers, also das Setzen von Breakpoints und die Anzeige aktueller Variablenwerte während der Ausführung (dazu jeweils später mehr). Das Programm funktioniert mit dem Netscape Navigator ab Version 4.06 (wegen der JDK1.1-Unterstützung) und baut auf der LiveConnect-Schnittstelle auf. Der Debugger selbst ist eine Java-Applikation, die über LiveConnect auf das JavaScript-Programm zugreifen kann.

Installation

Die Installation ist recht schnell bewerkstelligt – lesen Sie unter http://developer.netscape.com/software/jsdebug_license.html die Lizenzbestimmungen durch, und klicken Sie dann auf die Schaltfläche I Accept. Über den SmartUpdate-Mechanismus von Netscape wird die Software installiert (Java-Meldungen, die die Einräumung besonderer Rechte verlangen, müssen mit Grant bestätigt werden). Sodann befindet sich im Programm-Verzeichnis von Netscape (beispielsweise C:\Programme\Netscape\Communicator\Program) ein Unterverzeichnis JSDebug, in dem sich die Startseite des Debuggers befindet: jsdebugger.html.

Abbildung 23.2 Der Bildschirm nach dem Starten des Debuggers

Öffnen Sie diese Datei in Ihrem Webbrowser (wohlgemerkt: der Debugger funktioniert nur mit dem Internet Explorer!), und nach der Bestätigung weiterer Java-Meldungen erscheint das Debugger-Fenster auf dem Bildschirm.

23.2.1 Wo ist der Fehler?

Nun benötigen wir noch ein fehlerhaftes Programm. Kaufen Sie also ein Konkurrenzwerk (just kidding), oder werfen Sie einen Blick auf das folgende kurze Programm:

<HTML>
<HEAD>
<TITLE>Debugger</TITLE>
<SCRIPT LANGUAGE="JavaScript"><!--
var summe = 0
var zaehler = 0
var obergrenze

function ungerade(){
   zaehler++
   var summe = summe + zaehler
   if (zaehler<obergrenze)
     gerade()
}
function gerade(){
   zaehler++
   var summe = summe + zaehler
   if (zaehler<obergrenze)
     ungerade()
}
function sum(n){
   obergrenze = n
   ungerade()
   return summe
}
//--></SCRIPT>
</HEAD>
<BODY>
<SCRIPT LANGUAGE="JavaScript"><!--
   document.write(sum(100))
//--></SCRIPT>
</BODY>
</HTML>

Das Prinzip des obigen Programms ist relativ einfach. Hauptfunktion ist sum(n), welche die Summe der Zahlen von 1 bis n berechnet. Um das ganze ein wenig zu verkomplizieren, wird folgendermaßen vorgegangen: In der globalen Variablen summe wird das aktuelle Zwischenergebnis gespeichert, in der globalen Variable zaehler merkt sich das Programm, welche Zahlen bis jetzt schon aufsummiert worden sind. Zunächst wird die Funktion ungerade() aufgerufen, welche zunächst den Zähler um 1 erhöht (beim ersten Aufruf: auf 1), und dann den Wert des Zählers zur Zwischensumme addiert. Danach wird die Funktion gerade() aufgerufen, welche genau dasselbe erledigt: Zunächst Zähler erhöhen (beim ersten Aufruf: auf 2), und dann Zählerwert zur Zwischensumme hinzuzählen. Sobald der Zähler die Obergrenze erreicht hat, wird abgebrochen.

Schnelle Lösung

Wenn man der Legende Glauben schenkt, hat Gauß schon im Grundschulalter diese Aufgabe gelöst. Sein Lehrer wollte ihn ein wenig beschäftigen und bat ihn, die Zahlen von 1 bis 100 zu addieren. Der kleine Gauß hat ein wenig herumüberlegt und herausgefunden, dass sich die Summe der Zahlen von 1 bis n mit der Formel n(n+1) berechnen kann, bei n=100 kommt 5050 heraus.

Wenn Sie das Skript im Browser aufrufen (vorher unbedingt den Debugger starten, wie oben beschrieben!), werden Sie jedoch erstaunt feststellen, dass als Ergebnis 0 angezeigt wird. Woran kann das liegen?

Der Debugger weiß hier vielleicht Rat. Wechseln Sie ins Debugger-Fenster, klicken Sie auf die Schaltfläche Open, und klicken Sie dann doppelt auf die gerade geladene URL. Der Quellcode der Seite wird in den Debugger geladen, Skriptelemente sind dadurch durch einen ockerfarbenen Rand gekennzeichnet.

Abbildung 23.3 Code ist mit einem ockergelben Rand gekennzeichnet.

23.2.2 Breakpoints

Um den Debugger wirklich nutzen zu können, müssen Sie einen so genannten Breakpoint setzen. Die wörtliche Übersetzung, Unterbrechungspunkt oder auch Haltepunkt, ist schon sehr nahe an der Wahrheit. Sobald der JavaScript-Interpreter beim Haltepunkt angekommen ist, wird die Skriptausführung unterbrochen, und Sie können beispielsweise auf den aktuellen Wert aller Variablen zugreifen.

Breakpoints beziehen sich immer auf eine Zeile; die Programmausführung wird unterbrochen, bevor der Code in der Zeile ausgeführt wird. Prinzipiell gibt es zwei Möglichkeiten, einen Breakpoint zu setzen:

Klicken Sie in die entsprechende Zeile, und wählen Sie in der Symbolleiste die Schaltfläche BrkPt oder den Menübefehl Control • Set Breakpoint.

Klicken Sie in der entsprechenden Zeile in den ockerfarbenen Rand.

Egal, welche der beiden Methoden Sie einsetzen, Sie sehen danach einen roten Punkt links vom Rand, wodurch das Vorhandensein eines Breakpoints angedeutet wird.

In diesem Beispiel sollten Sie den Breakpoint in die Zeile zaehler++ der Funktion ungerade() setzen. Tun Sie das, und laden Sie im Browserfenster das (fehlerhafte) Skript erneut. Nach kurzer Zeit werden Sie im Debuggerfenster feststellen, dass sich im ockerfarbenen Rand ein kleiner Pfeil befindet, der die aktuelle Position der Skriptausführung markiert.

23.2.3 Watches

Es ist nun an der Zeit, die Werte einiger Variablen zu betrachten. Unter Windows • Watches können Sie sogenannte Watches einstellen. Das sind Variablen, deren Wert Sie permanent überwachen möchten. Mit Klick auf die Schaltfläche New können Sie eine neue Watch angeben. Es empfiehlt sich in diesem Beispiel, ein genaueres Augenmerk auf die Variablen summe und zaehler zu werfen. Erstellen Sie also zwei Watches – eine für die Variable summe, und eine für die Variable zaehler. Im Watches-Fenster werden die Variablennamen dann angezeigt. Wenn Sie die Schaltfläche eval wählen, werden die aktuellen Werte all dieser Variablen in der Konsole (rechts unten zu sehen) angezeigt.

Abbildung 23.4 Watches werden in der Konsole angezeigt.

Mit Done können Sie das Watches-Fenster wieder schließen. Sobald sich der Wert einer der Variablen ändert, wird der neue Wert in der Konsole angezeigt. Sie müssen eigentlich nur noch das Programm weiterlaufen lassen und dabei zusehen, was geschieht.

Sollte die Konsole recht voll und unübersichtlich werden, können Sie den Inhalt mit Edit • Clear Console wieder löschen.

23.2.4 Einzelne Werte anzeigen

Erst ab Debugger-Version 1.1

Anstelle einer Watch können Sie, wenn Sie einen Wert nicht permanent überwachen möchten, sich auch nur den Wert einer beliebigen Variablen einmalig anzeigen lassen. Hierzu dient der Inspector (eine Neuerung, erst ab Version 1.1 des Debuggers). Dort können Sie vereinfacht gesagt eval()-Anweisungen ausführen. Geben Sie im Inspector-Fenster (sie können über das Menü Windows darauf zugreifen) einen Variablen- oder einen Objektnamen ein, und der entsprechende Wert wird Ihnen angezeigt.

Abbildung 23.5 Im Inspector können Sie den Wert einer Variable auswerten.

Objekthierarchien

Besonders interessant ist hier die Möglichkeit, Einsicht in Objekthierarchien zu gewinnen. Geben Sie beispielsweise im Inspector document ein. Sie sehen dann eine Auflistung aller Eigenschaften des document-Objekts, und können sich im Hierarchiebaum weiter nach unten bewegen (beispielsweise in document.forms). Insbesondere bei Mouseover-Effekten ist das sehr praktisch, wenn Sie nicht mit Bildnamen, sondern mit Indizes operieren. Schnell hat man sich verzählt, aber im Inspector sieht man genau, woran es eigentlich hakt.

Abbildung 23.6 Auflistung des document-Objekts

23.2.5 Schrittweise Programmausführung

Sie sehen in der Symbolleiste ganz rechts fünf Schaltflächen, mit denen Sie die Skriptausführung wieder in Gang setzen können. Der Reihe nach haben diese die folgenden Funktionen:

Run: Das Programm wird weiter ausgeführt, bis es entweder am Ende ankommt oder wieder bei einem Breakpoint stehen bleiben muss.

Over: Es wird zur nächsten Zeile in der aktuellen Funktion gesprungen. Sollte der Interpreter am Ende der Funktion angelangt sein, verhält sich die Schaltfläche wie Run.

Into: Es wird zur nächsten Zeile des Programmcodes gesprungen, ganz egal, ob die innerhalb der aktuellen Funktion liegt oder außerhalb.

Out: Die aktuelle Funktion wird verlassen, und das Programm weiter ausgeführt, bis es endet oder am nächsten Breakpoint stehen bleiben muss.

Abort: Die Skriptausführung wird unterbrochen (beispielsweise bei einer Endlosschleife).

Beachten Sie nun genau, was geschieht, wenn Sie von der Zeile zaehler++ aus mit Into weiter vorgehen. Anfangs hat zaehler einen Wert von 0 und summe einen Wert von null. Nach der Ausführung des Kommandos zaehler++ hat zaehler den Wert 1, der Wert von summe hat sich nicht geändert. In der nächsten Zeile jedoch ändert sich der Wert von summe. Nicht, wie erhofft auf 1, sondern auf ... NaN, not a number. Warum nur?

Der Fehler im Skript

Mit ein wenig Überlegung ist klar, wo der Fehler liegt. Vor der Anweisung summe = summe + zaehler steht ein var. Dadurch wird summe innerhalb der Funktion ungerade() – und analog dazu auch in gerade() – zu einer lokalen Variablen, deren Wert außerhalb der Funktion nicht sichtbar ist. Die Variable summe ist aber eigentlich als globale Variable konzipiert.

Entfernen Sie sowohl in der Funktion ungerade() als auch in der Funktion gerade() das Schlüsselwort var vor summe, brechen Sie im Debugger die Skriptausführung ab, wählen Sie dann den Menübefehl File • Refresh All, und laden Sie die Seite im Browser neu. Ein Blick in die Konsole verheißt Gutes, denn nun wird summe anständig erhöht. Und wenn Sie nun noch den Breakpoint entfernen (Control • Clear Breakpoint, oder in den ockerfarbenen Bereich klicken) und das Skript durchlaufen lassen, sehen Sie im Browser auch das korrekte Ergebnis – 5050. Wir haben zwar etwas länger gebraucht als der kleine Gauß, aber dafür durften wir ja auch nicht per Hand rechnen.

23.3 Fragen

Erstellen Sie die oben angedeutete Lösung, beim Auftreten einer Fehlermeldung per clientseitigem mailto:-Formular eine E-Mail an Sie zu erzeugen. Aus den bekannten Gründen müssen Sie das Skript ein wenig abändern – Ihr Besucher muss das Formular von Hand verschicken, Sie benötigen also eine Versenden-Schaltfläche.

2.	Was könnten Sie tun, wenn Sie wissen, dass in einer ganz bestimmten Zeile bei ganz bestimmten Browsern ein Fehler auftritt, den Sie einfach nicht beheben können? Oder, anders gefragt: Wie unterdrücken Sie ausschließlich diese Fehlermeldung?

3.	Haben Sie eine Vermutung, wieso der Wert von summe im (falschen) Debugger-Beispiel den Wert null hatte, und nicht den Wert 0?

4.	Versuchen Sie zu bergründen, wozu der Befehl Control • Edit Breakpoint (ist aktiv, wenn sich der Cursor in einer Zeile mit einem Breakpoint befindet) dient.

<< zurück

<top>

vor >>