Anweisungen (Kontrollfluss)

  • Adressname der Version: JavaScript/Guide/Statements
  • Titel der Version: Anweisungen
  • ID der Version: 327443
  • Erstellt:
  • Autor: eminor
  • Aktuelle Version? Nein
  • Kommentar

Inhalt der Version

JavaScript unterstützt einen kompakten Satz von Anweisungen, die eingesetzt werden können, um Websites interaktiv zu gestalten. Dieses Kapitel bietet eine Übersicht zu diesen Anweisungen.

Jeder Ausdruck ist auch eine Anweisung. Das Kapitel Ausdrücke und Operatoren stellt hierzu mehr Informationen bereit.

Zur Trennung von Anweisungen wird das Semikolon (;) verwendet. Die JavaScript-Referenz informiert darüber genauer.

Blockstruktur

Anweisungen werden durch Anweisungsblöcke gruppiert und zusammengefasst. Ein Anweisungsblock wird durch geschweifte Klammern festgelegt:

{
   Anweisung_1;
   Anweisung_2;
   .
   .
   .
   Anweisung_n;
}

Beispiel
Anweisungsblöcke werden vorwiegend in Verbindung mit Anweisungen zur Flusskontrolle eingesetzt (z. B. if, for, while).

while (x < 10){
  x++;
}

Bei diesem Beispiel ist { x++; } der Anweisungsblock.

Wichtig: JavaScript grenzt die Sichtbarkeit (Scope) von Blöcken nicht ab. Variablen, die innerhalb eines Blocks deklariert werden, sind innerhalb der Funktion oder des Skripts sichtbar und bleiben auch innerhalb dieses Bereichs erhalten. Mit anderen Worten: Anweisungsblöcke erzeugen keinen seperaten Sichtbarkeitsbereich. Obwohl es auch eigenständige Blockanweisungen (standalone) gibt und diese zur Syntax gehören, sollte man auf deren Einsatz besser verzichten, da sie nicht auf dieselbe Weise funktionieren wie z. B. bei C oder Java.

Beispiel:

var x = 1;
{
  var x = 2;
}
alert(x); // Ausgabe: 2

Die Ausgabe ist hier 2, weil sich die Anweisung var x, die sich innerhalb des Anweisungsblocks befindet im selben Sichtbarkeitsbereich liegt, wie die andere var x-Anweisung, die vor dem Anweisungsblock steht. Bei C oder Java wäre die Ausgabe 1.

Bedingte Anweisungen

Bei einer bedingten Anweisung wird ein Satz von Befehlen ausgeführt, wenn eine bestimmte festgelegte Bedingung erfüllt ist. JavaScript kennt hierfür zwei verschiedene Anweisungen: if...else und switch.

if...else-Anweisung

Die if Anweisung sollte eingesetzt werden, wenn bestimmte Anweisungen ausgeführt werden sollen, falls eine logische Bedingungen erfüllt ist. Zusätzlich kann ein optionaler else-Abschnitt festgelegt werden, dessen Anweisungen ausgeführt werden, falls die Bedingung nicht erfüllt ist. Die Syntax einer if Anweisung ist wie folgt:

if (Bedingung)
  Anweisung_1
[else
  Anweisung_2]

Die Bedingung kann jeder Ausdruck sein, der zu true oder false evaluiert. Wenn die Bedingung zu true ist, wird Anweisung_1 ausgeführt, andernfalls wird Anweisung_2 ausgeführt. Anweisung_1 und Anweisung_2 können für beliebige Anweisungen stehen, auch weitere verschachtelte if-Anweisungen könnten an dieser Stelle eingesetzt werden.

Darüber hinaus ist es mit Hilfe von else if möglich, mehrere Bedingungen nacheinander zu überprüfen (Verzweigung):  

if (Bedingung)
  Anweisung_1
[else if (Bedingung_2)
  Anweisung_2]
...
[else if (Bedingung_n_1)
  Anweisung_n_1]
[else
  Anweisung_n]

Sollen mehrere Anweisungen ausgeführt werden, müssen sie innerhalb eines Anweisungsblocks ({ ... }) stehen. Es ist gute Praxis, die Blöcke immer angeben, auch wenn sie für einzelne Anweisungen nicht zwingend notwendig sind. Insbesondere bei verschachtelten if-Anweisungen wird hierdurch die Lesbarkeit verbessert.

if (condition) {
  statements_1
} else {
  statements_2
}

Auch ist es empfehlenswert keine Zuweisungen an der Stelle für die Bedingung vorzunehmen, weil diese aufgrund des Gleichzeichens leicht mit Vergleichen verwechselt werden können. Der folgende Code sollte also nicht verwendet werden:

if (x = y) {
  /* do the right thing */
}

Wenn man eine Zuweisung in einem bedingten Ausdruck vornehmen möchte, sollte diese in zusätzliche Klammern eingeschlossen werden. Zum Beispiel:

if ((x = y)) {
  /* mach das Richtige */
}

Die folgenden Werte evaluieren zu false:

  • false
  • undefined
  • null
  • 0
  • NaN
  • die leere Zeichenkette ("")

Alle anderen Werte, einschließlich aller Objekte, evaluieren zu true, wenn sie als Bedingung angegeben werden.

Vorsicht: Die primitiven booleschen Werte wie true und false sollten nicht mit den Werten true und false des booleschen Objekts (Boolean) verwechselt werden.

Zum Beispiel:

var b = new Boolean(false);
if (b) // diese Bedingung evaluiert zu true

Beispiel

Beim folgenden Beispiel liefert die Funktion checkData den Wert true, wenn die Anzahl der Zeichen eines Text-Objekts dem Wert 3 entspricht. Andernfalls wird eine Alarm-Nachricht ausgegeben und false zurückgegeben.

function checkData() {
  if (document.form1.threeChar.value.length == 3) {
    return true;
  } else {
    alert("Bitte genau 3 Zeichen eingeben. " +
      document.form1.threeChar.value + " is not valid.");
    return false;
  }
}

switch-Anweisung

Bei der switch-Anweisung wird ein Ausdruck ausgewertet und das Ergebnis mit den unterschiedlichen Ausdrücken der case-Labels verglichen (Fallunterscheidung). Stimmen die Werte überein, werden die Anweisungen des entsprechenden case-Abschnitts ausgeführt.

Beispiel:

switch (Ausdruck) {
   case Label_1:
      Anweisung_1
      [break;]
   case Label_2:
      Anweisung_2
      [break;]
   ...
   default:
      Anweisung_falls_keine_case_Ausdruck_passt
      [break;]
}

Bei diesem Skript wird zuerst nach einem case-Abschnitt gesucht dessen Wert mit dem Wert des in Klammern spezifizierten Ausdrucks übereinstimmt. Wird ein solcher Wert gefunden, werden die Anweisungen des case-Abschnitts ausgeführt. Sollte keiner der Werte mit dem Wert des Ausdrucks übereinstimmen, wird nach einem default-Abschnitt gesucht und falls vorhanden, die Kontrolle an diesen übergeben und die entsprechenden Anweisungen ausgeführt. Falls kein default-Abschnitt vorhanden ist, wird die Ausführung hinter der switch-Anweisung fortgesetzt. Dem Standard nach sollte der default-Abschnitt an letzter Stelle stehen, jedoch ist er keine Pflicht.

Die optionale break-Anweisung innerhalb jedes case-Abschnitts bewirkt den Abbruch der switch-Anweisung. Die Ausführung wird dann hinter der switch-Anweisung fortgesetzt. Wenn break nicht angegeben ist, findet kein Abbruch statt und die Anweisungen folgender case-Abschnitte werden ebenfalls ausgeführt, falls deren Label-Wert mit dem Wert des Ausdrucks übereinstimmt.

Beispiel
Beim folgenden Beispielcode evaluiert fruittype zu "Bananen". Daraufhin wird eine Übereinstimmung beim case-Abschnitt "Bananen" gefunden und die Anweisungen dieses Abschnitts werden ausgeführt. Anschließend wird die switch-Anweisung an der Stelle des break verlassen und die Ausführung hinter dem switch-Block fortgesetzt. Wenn kein break innerhalb des Bananen-Abschnitts angegeben wäre, würde der Abschnitt "Kirschen" ebenfalls (bis zu break) ausgeführt werden.

switch (fruittype) {
   case "Orangen":
      document.write("Orangen kosten 0.59 EUR das Pfund.<br>");
      break;
   case "Birnen":
      document.write("Birnen kosten 0.32 EUR das Pfund.<br>");
      break;
   case "Bananen":
      document.write("Bananen kosten  0.48 EUR das Pfund.<br>");
      break;
   case "Kirschen":
      document.write("Kirschen kosten 3.00 EUR das Pfund.<br>");
      break;
   case "Mangos":
   case "Papayas":
      document.write("Mangos und Papayas kosten 2.79 EUR das Pfund.<br>");
      break;
   default:
      document.write("Entschuldigung, " + fruittype + "sind ausverkauft.<br>");
}
document.write("Darf es sonst noch etwas sein?<br>");

Schleifen-Anweisungen

Eine Schleife ist ein Satz von Befehlen, die solange wiederholt ausgeführt werden, bis eine bestimmte Bedingung erfüllt ist. Javascript unterstützt die Anweisungen for, do while und while, sowie Labels (Labels sind nicht direkt eine Schleifenanweisung, werden aber sehr oft mit diesen zusammen verwendet). Zusätzlich können die beiden Anweisungen break und continue zum Einsatz kommen.

Eine weitere Anweisung ist for...in, welche ebenfalls wiederholt Anweisungen ausführt, jedoch zur Manipulation von Objekten verwendet wird. Siehe {{ linkToFragment("Object Manipulation Statements") }}.

Die Schleifen-Anweisungen sind:

  • {{ linkToFragment("for-Anweisung") }}
  • {{ linkToFragment("do...while-Anweisung") }}
  • {{ linkToFragment("while-Anweisung") }}
  • {{ linkToFragment("label-Anweisung") }}
  • {{ linkToFragment("break-Anweisung") }}
  • {{ linkToFragment("continue-Anweisung") }}

for-Anweisung

Eine for-Schleife führt wiederholt Anweisungen aus, bis eine festgelegte Bedingung zu false evaluiert. Die Syntax der for-Schleife ist ähnlich wie bei Java und C:

for ([Initialisierungsausdruck]; [Bedingung]; [Inkrementierungsausdruck])
   Anweisung

Wenn eine for-Schleife ausgeführt wird, passiert folgendes:

  1. Der Initialisierungsausdruck wird (falls angegeben) ausgeführt. Der Ausdruck initialisiert für gewöhnlich eine oder mehrere einfache Variablen, die zur Schleifenzählung verwendet werden. Die Syntax erlaubt jedoch Anweisungen beliebiger Komplexität. Auch Variablen-Zuweisungen sind erlaubt.
  2. Der Ausdruck Bedingung wird ausgewertet. Wenn der Wert true ist, wird die Anweisung ausgeführt. Wenn der Wert der Bedingung false ist, wird die Schleife abgebrochen. Fehlt der Ausdruck Bedingung komplett, wird angenommen, dass der Wert der Bedingung true ist.
  3. Die Anweisung wird ausgeführt. Bei mehreren Anweisungen muss eine Blockanweisung ({ ... }) zur Gruppierung verwendet werden.
  4. Der Inkrementierungsausdruck (üblicherweise wird die Zählvariable inkrementiert), falls angegeben, wird ausgeführt und der nächste Schleifendurchlauf gestartet (Schritt 2). Dies wird solange wiederholt, bis die Bedingung nicht mehr erfüllt ist.

Beispiel

Die Funktion im folgenden Code enthält eine for-Schleife, welche die Anzahl der ausgewählten Optionen in einer Liste zählt. Die for-Schleife deklariert die Variable i und initialisiert sie mit dem Wert 0. Die Schleife überprüft, ob i kleiner ist als die Anzahl der verfügbaren Optionen des select-Objekts, welches die Auswahl mehrerer Optionen erlaubt. Solange dies zutrifft wird wiederholt der Anweisungsblock mit der if-Anweisung ausgeführt und der Wert der Variablen i nach jedem Schleifendurchlauf um 1 erhöht.

<script type="text/javascript">

function howMany(selectObject) {
   var numberSelected = 0;
   for (var i = 0; i < selectObject.options.length; i++) {
      if (selectObject.options[i].selected)
         numberSelected++;
   }
   return numberSelected;
}

</script>
<form name="selectForm">
   <p>
      <strong>Choose some music types, then click the button below:</strong>
      <br/>
      <select name="musicTypes" multiple="multiple">
         <option selected="selected">R&B</option>
         <option>Jazz</option>
         <option>Blues</option>
         <option>New Age</option>
         <option>Classical</option>
         <option>Opera</option>
      </select>
   </p>
   <p>
      <input type="button" value="How many are selected?"
         onclick="alert ('Number of options selected: ' + howMany(document.selectForm.musicTypes))"/>
   </p>
</form>

do...while Anweisung

Bei der do...while-Anweisung wird die Ausführung solange wiederholt bis eine bestimmte Bedingung zu false evaluiert. Die Syntax einer do...while-Anweisung ist wie folgt:

do
   Anweisung
while (Bedingung);

Die Anweisung wird einmal ausgeführt bevor die Bedingung überprüft wird. Um mehrere Anweisungen auszuführen, muss eine Blockanweisung zur Gruppierung eingesetzt werden. Wenn der Wert der Bedingung true ist, wird die Anweisung erneut ausgeführt. Die Bedingung wird nach jedem Durchlauf überprüft und die Schleife abgebrochen, wenn die Bedingung nicht mehr erfüllt ist.

Beispiel

Beim folgenden Beispiel wird zuerst ein Schleifendurchlauf durchgeführt. Anschließend wird die Bedingung überprüft und solange weitere Schleifendurchläufe durchgeführt, bis i nicht mehr kleiner als 5 ist.

do {
   i += 1;
   document.write(i);
} while (i < 5);

while-Anweisung

Eine while-Anweisung führt Anweisungen solange wiederholt aus wie eine bestimmte Bedingung zu true evaluiert. Eine while Anweisung sieht wie folgt aus:

while (Bedingung)
   Anweisung

Wenn die Bedingung nicht mehr erfüllt ist, stoppt die Ausführung der Anweisung und die Ausführung wird hinter der Schleife fortgesetzt.

Die Bedingung wird gleich zu Beginn vor der Ausführung der Anweisung überprüft. Wenn die Bedingung erfüllt ist, wird die Anweisung ausgeführt und die Bedingung erneut überprüft. Wenn die Bedingung nicht erfüllt ist, wird die Schleife abgebrochen und die Ausführung hinter der Schleife fortgesetzt.

Auch bei der while-Schleife müssen mehrere Anweisungen durch einen Anweisungsblock ({ ... }) gruppiert werden.

Beispiel 1

Die folgende while-Schleife wird ausgeführt, solange n kleiner als 3 ist:

n = 0;
x = 0;
while (n < 3) {
   n++;
   x += n;
}

Mit jeder Iteration wird die Variable n inkrementiert und der Wert zu x hinzuaddiert. Daher nehmen x und n im Verlauf die folgenden Werte an:

  1. Nach dem ersten Durchlauf: n = 1 und x = 1
  2. Nach dem zweiten Durchlauf: n = 2 und x = 3
  3. Nach dem dritten Durchlauf: n = 3 und x = 6

Nachdem der dritte Durchlauf abgeschlossen ist, ist die Bedingung n < 3 nicht mehr erfüllt und die Schleife wird abgebrochen.

Beispiel 2

Man sollte unbedingt darauf achten, keine Endlos-Schleifen zu programmieren, also sicherstellen, dass die Bedingung früher oder später nicht mehr erfüllt ist, sodass die Schleife abbricht. Die Anweisungen des folgenden Codes werden unendlich wiederholt ausgeführt, weil die Bedingung niemals zu false evaluiert:

while (true) {
   alert("Hello, world");
}

Label-Anweisungen

Ein Label ist ein Bezeichner, der eine Stelle markiert, die als Sprungziel dient. Zum Beispiel kann mit einem Label eine Schleife markiert und anschließend mit Hilfe von break oder continue die Schleife unterbrochen oder beim nächsten Durchlauf fortgesetzt werden.

Syntax:

Label :
   Anweisung


Der Wert von Label kann ein JavaScript-Bezeichner sein, der jedoch keines der reservierten Wörter von JavaScript sein darf. Anweisung kann für beliebige Anweisungen stehen.

Beispiel
Bei diesem Beispiel markiert das Label markLoop eine while-Schleife:

markLoop:
while (theMark == true) {
   doSomething();
}

break-Anweisung

Die break-Anweisung wird  in Verbindung mit Schleifen, switch-Anweisungen oder mit Labels zum Abbruch eingesetzt.

  • Wenn break ohne ein Label verwendet wird, terminiert es das innerste while, do-while, for, oder switch und gibt die Kontrolle an die dahinterstehende Anweisung weiter.
  • Wenn break mit einem Label eingesetzt wird, terminiert es die angegebende Label-Anweisung.

Die Syntax von break-Anweisungen ist wie folgt:

  1. break;
  2. break Label;

Die erste Form terminiert die innerste Schleife oder switch-Anweisung. Die zweite Form terminiert die angegebene Label-Anweisung.


Beispiel 1:
Beim folgenden Beispiel wird solange über die Elemente eines Arrays iteriert, bis der index eines Elements gefunden wird, dessen Wert derWert entspricht:

for (i = 0; i < a.length; i++) {
   if (a[i] == derWert)
      break;
}

Beispiel 2: Abbruch und Sprung zu einem Label

var x = 0;
var z = 0
labelCancelLoops: while (true) {
    console.log("Outer loops: " + x);
    x += 1;
    z = 1;
    while (true) {
        console.log("Inner loops: " + z);
        z += 1;
        if (z === 10 && x === 10) {
            break labelCancelLoops;
        } else if (z === 10) {
            break;
        }
    }
}

continue-Anweisung

Mit der continue-Anweisung wird ein Sprung zum nächsten Schleifendurchlauf veranlasst.

  • Wenn continue ohne ein Label eingesetzt wird, bricht es den aktuellen Durchlauf der innersten while-, do-while- oder for-Anweisung ab und die Ausführung wird bei der nächsten Iteration fortgesetzt. Im Gegensatz zu break wird bei continue die Schleife nicht komplett abgebrochen, sondern nur der aktuelle Durchlauf der Schleife. Bei einer while-Schleife wird ein Sprung zurück zur Bedingung durchgeführt. Bei einer for-Schleife bewirkt continue einen Sprung zum Inkrementierungsausdruck.
  • Steht nach continue ein Label, bewirkt es einen Sprung zu diesem Label.


Die Syntax der continue-Anweisung ist wie folgt:

  1. continue
  2. continue Label

Beispiel 1
Das folgende Beispiel zeigt eine while-Schleife mit einer continue-Anweisung, die ausgeführt wird, wenn i den Wert 3 besitzt. Im Verlauf der Ausführung nimmt n die Werte 1, 3, 7 und 12 an.

i = 0;
n = 0;
while (i < 5) {
   i++;
   if (i == 3)
      continue;
   n += i;
}

Beispiel 2
Eine Anweisung mit dem Label checkiandj enthält eine weitere Anweisung mit dem Label checkj. Wenn continue erreicht ist, bricht das Skript die aktuelle Iteration von checkj ab und startet die nächste Iteration. Jedes Mal, wenn continue erreicht ist, wird checkj erneut durchlaufen, solange bis die Bedingung der if-Anweisung zu false evaluiert. Wenn false zurückgegeben wird, wird der Rest des Codes von checkiandj bis zum Ende ausgeführt und checkiandj wiederholt, bis die zugehörige Bedingung zu false evaluiert. Wenn false zurückgegeben wird, wird die Ausführung bei der Anweisung hinter checkiandj fortgesetzt.

Wenn bei continue das Label checkiandj angegeben wäre, würde das Skript am Anfang der checkiandj-Anweisung fortgesetzt.

checkiandj :
   while (i < 4) {
      document.write(i + "<br/>");
      i += 1;
      checkj :
         while (j > 4) {
            document.write(j + "<br/>");
            j -= 1;
            if ((j % 2) == 0)
               continue checkj;
            document.write(j + " is odd.<br/>");
         }
      document.write("i = " + i + "<br/>");
      document.write("j = " + j + "<br/>");
   }

Anweisungen zur Objekt-Manipulation

JavaScript benutzt die Anweisungen for...in, for each...in, und with zur Manipulation von Objekten.

for...in-Anweisung

Die Anweisung for...in iteriert eine bestimmte Variable über alle Eigenschaften eines Objekts. Bei jedem Schleifendurchlauf wird Variable der Name der Eigenschaft zugewiesen. Die Anweisungen werden für jede vorhandene Eigenschaft einmal ausgeführt.

Syntax:

for (Variable in Objekt) {
   Anweisungen
}

Beispiel
Die folgende Funktion nimmt ein Objekt als Argument und den Namen des Objekts entgegen. Anschließend wird mit Hilfe von for...in über alle Objekteigenschaften iteriert und ein String mit dem Namen und dem Wert der Eigenschaft zurückgegeben.

function dump_props(obj, obj_name) {
   var result = "";
   for (var i in obj) {
      result += obj_name + "." + i + " = " + obj[i] + "<br>";
   }
   result += "<hr>";
   return result;
}

Bei einem Objekt automobil mit den Eigenschaften hersteller und modell wäre das Ergebnis:

automobil.hersteller = Ford
automobil.modell = Mustang

Arrays

Obwohl es sinnvoll erscheinen mag, eine for...in-Anweisung zu benutzen, um über die Elemente eines Arrays zu iterieren, weil die for...in-Anweisung zusätzlich zu den Array-Elementen auch benutzerdefinierte Eigenschaften und Methoden erfasst, sollte besser eine normale for-Schleife benutzt werden, um über Array-Elemente zu interieren, da bei benutzerdefinierten Methoden nicht nur ein numerischer Index, sondern auch der Name der benutzerdefinierten Eigenschaften oder Methoden zurückgegeben wird.

for each...in Anweisung

for each...in ist eine Schleifenanweisung, die mit JavaScript 1.6 eingeführt wurde. Sie ist ähnlich wie for...in, aber iteriert über die Werte von Objekt-Eigenschaften und nicht über die Namen.

var sum = 0;
var obj = {prop1: 5, prop2: 13, prop3: 8};
for each (var item in obj) {
  sum += item;
}
print(sum); // gibt 26 aus, also die Summe von 5+13+8

Kommentare

Kommentare sind Bemerkungen der Autorin/des Autors, welche die Funktion von Code beschreiben. Kommentare werden vom Interpreter ignoriert. JavaScript unterstützt die Syntax für Kommentare im Stil von Java und C++:

  • Einzeilige Kommentare werden durch doppelte Schrägstriche (//) eingeleitet.
  • Kommentare über mehrere Zeilen werden in /* und */ eingeschlossen.

Beispiel
Der folgende Code demonstriert die beiden Varianten zur Kennzeichnung von Kommentaren:

// Dies ist ein einzeiliger Kommentar.

/* Dies ist ein mehrzeiliger Kommentar. 
Er kann sich über beliebig viele Zeilen erstrecken 
und beliebige Zeichen enthalten. */

Anweisungen zur Ausnahmebehandlung (Exceptions)

Mit der Anweisung throw wird eine Ausnahmenbehandlung eingeleitet und Werte von Ausdrücken ausgeworfen. Außerdem lässt sich mit Hilfe der try...catch-Anweisung auf Ausnahmen reagieren.

Mit try...catch können auch Java-Ausnahmen behandelt werden (Vorsicht: {{ bug("391642") }} ). Unter Handling Java Exceptions in JavaScript und JavaScript to Java Communication wird genauer auf das Thema eingegangen.

  • {{ linkToFragment("throw Statement") }}
  • {{ linkToFragment("try...catch Statement") }}

Typen von Ausnahmen

Nahezu jedes Objekt kann in JavaScript ausgeworfen werden, jedoch werden nicht alle Objekte auf dieselbe Weise erstellt. Obwohl es üblich ist, dass Ziffern oder Zeichenketten als Error ausgeworfen werden, ist es weit mehr effektiver, einen der Ausnametypen zu benutzen, die speziell für diesen Zweck entwickelt wurden.

throw-Anweisung

Die throw-Anweisung wird eingesetzt, um eine Ausnahmebehandlung einzuleiten und einen Ausdruck auszuwerfen. Der Ausdruck, dessen Wert ausgeworfen werden soll, wird hinter throw angegeben:

throw Ausdruck;

Der Ausdruck muss nicht von einem speziellen Typ sein, sondern es kann jede Art von Ausdruck benutzt werden. Der folgende Code wirft verschiedene Ausnahmen mit unterschiedlichen Typen aus:

throw "Error2";
throw 42;
throw true;
throw {toString: function() { return "Ich bin ein Objekt!"; } };
Note: Man kann beim Auswerfen von Ausnahmen auch Objekte angeben. Im Anschluss kann im catch-Block auf die Eigenschaften dieses Objekts zugegriffen werden. Beim folgenden Beispiel wird ein Objekt myUserException mit dem Typ UserException erstellt und dieses in einer throw-Anweisung benutzt.
// Erstellen eines Objekt-Typs UserException 
function UserException (message){
  this.message=message;
  this.name="UserException";
}

// Konvertieren der Ausnahme zu einem String,
// wenn sie als String benutzt wird (z .B. von der Error-Konsole)
UserException.prototype.toString = function (){
  return this.name + ': "' + this.message + '"';
}

// Erstellen einr Instanz des Objekt-Typs und Auswurf
throw new UserException("Value too high");

try...catch-Anweisung

Bei der try...catch-Anweisung wird ein Block von Anweisungen "ausprobiert" und auf gegebenenfalls auftretende Ausnahmen reagiert. Wenn eine Ausnahme ausgeworfen wird, wird sie von der try...catch-Anweisung abgefangen.

Die try...catch-Anweisung besteht aus einem try-Block, welcher eine oder mehrere Anweisungen enthält und einem oder mehreren catch-Blöcken, die Anweisungen enthalten und jeweils bestimmen, was beim Auftreten einer bestimmten Ausnahme getan werden soll. Man möchte in der Regel, dass der try-Block erfolgreich ausgeführt wird, doch falls Fehler auftreten, entsprechend mit den catch-Anweisungen darauf reagieren. Sobald eine Ausnahme durch den Code im try-Block (oder eine Funktion, die im try-Block ausgeführt wird) ausgelöst wurde, wird die Kontrolle an den catch-Block übergeben. Wenn keine Ausnahme im try-Block ausgelöst wird, wird der catch-Block nicht ausgeführt. Der finally-Block wird nach dem try- und catch-Block ausgeführt, jedoch bevor der Code nach dem try...catch ausgeführt wird. Mit dem finally-Block werden in der Regel Aufräumarbeiten durchgeführt.

Beim folgenden Beispiel kommt eine try...catch-Anweisung zur Anwendung. Es wird eine Funktion aufgerufen, die eine Zahl entgegen nimmt und anhand dieser einen Monatsnamen aus einem Array auswählt. Wenn der Wert keiner Monatszahl (1-12) entspricht, wird eine Ausnahme ausgelöst, welche den Wert "InvalidMonthNo" auswirft und die Anweisungen im catch-Block setzen die monthName-Variable auf unknown.

function getMonthName (mo) {
    mo=mo-1; // Adjust month number for array index (1=Jan, 12=Dec)
    var months=new Array("Jan","Feb","Mar","Apr","May","Jun","Jul",
          "Aug","Sep","Oct","Nov","Dec");
    if (months[mo] != null) {
       return months[mo]
    } else {
       throw "InvalidMonthNo"
    }
}

try {
// statements to try
    monthName=getMonthName(myMonth) // function could throw exception
}
catch (e) {
    monthName="unknown"
    logMyErrors(e) // pass exception object to error handler
}

Der catch-Block

Mit dem catch-Block kann jede Ausnahme, die im try-Block ausgelöst wird, abgefangen werden.

catch (catchID) {
  Anweisungen
}

Bei diesem catch-Block wurde ein Bezeichner catchID angegeben, welcher den Wert enthält, der von der throw-Anweisung ausgeworfen wird. Diesen Bezeichner kann man benutzen, um Informationen zu der ausgelösten Ausnahme zu erhalten. JavaScript erstellt diesen Bezeichner, wenn der catch-Block zur Ausführung kommt. Der Bezeichner bleibt nur für den catch-Block erhalten. Nachdem die Ausführung des catch-Blocks beendet ist, kann auf den Bezeichner nicht mehr zugegriffen werden.

Der folgende Code löst eine Ausnahme aus. Sobald die Ausnahme ausgelöst wird, wird der catch-Block ausgeführt.

try {
   throw "myException" // löst Ausnahme aus
}
catch (e) {
// Anweisungen um auf die Ausnahme zu reagieren
   logMyErrors(e) // Das Ausnahme-Objekt wird an eine Funktion übergeben
}

Der finally-Block

Der finally-Block enthält Anweisungen, die nach den try- und catch-Blöcken ausgeführt werden, jedoch bevor der Code hinter der try...catch-Anweisung ausgeführt wird. Der Block wird unabhängig davon ausgeführt, ob eine Ausnahme ausgelöst wurde oder nicht. Auch wenn gar kein catch-Block vorhanden ist, womit auf eine Ausnahme reagiert wird, wird der finally-Block ausgeführt.

Mit Hilfe des finally-Blocks kann man elegant auf Fehler in einem Skript reagieren. Zum Beispiel möchte man vielleicht Ressourcen wieder freigeben, die das Skript in Anspruch genommen hat, bevor ein Abbruch stattfindet. Beim folgenden Beispiel wird eine Datei geöffnet und Anweisungen ausgeführt, die mit der Datei arbeiten (serverseitiges Javascript erlaubt den Zugriff auf Dateien). Wenn eine Ausnahme ausgelöst wird während die Datei geöffnet ist, schließt der Code des finally-Blocks die Datei, bevor die Ausführung des Skripts abbricht.

openMyFile();
try {
    writeMyFile(theData); // Hier könnte ein Fehler passieren
}catch(e){
    handleError(e); // Fehlerbehandlung falls Fehler auftritt
}finally {
    closeMyFile(); // In jedem Fall Datei schließen
}

Wenn der finally-Block einen Wert zurückgibt, ist dieser Wert der return-Wert des kompletten try-catch-finally-Blocks, unabhängig davon welche return-Werte die Funktionen in den try- und catch-Blöcken zurückgeben.

function f() {
    try {
        alert(0);
        throw "bogus";
    } catch(e) {
        alert(1);
        return true; // Dieser return-Wert wird zurückgehalten bis der finally-Block ausgeführt wurde
        alert(2); // nicht erreichbar
    } finally {
        alert(3);
        return false; // überschreibt das vorherige "return"
        alert(4); // nicht erreichbar
    }
    // "return false" wird nun ausgeführt
    
    alert(5); // nicht erreichbar
}
f(); // alert-Meldungen: 0, 1, 3 und "return false" wird ausgeführt

Verschachteln von try...catch-Anweisungen

Man kann eine oder mehrere try...catch-Anweisungen verschachteln. Wenn eine innere try...catch-Anweisungen keinen catch-Block hat, wird die einschließende try-catch-Anweisung auf eine Übereinstimmung überprüft.

Einsatz von Error-Objekten

Je nach Art des Fehlers kann es möglich sein, dass auf die Eigenschaften "name" und "message" zugegriffen werden kann, um detaillierte Informationen zu erhalten. Die Eigenschaft "name" enthält die Fehlerklasse (z. B. "DOMException" oder "Error") und die Eigenschaft "message" in der Regel genauere Informationen, als wenn man nur das Error-Objekt zu einem String konvertiert.

Wenn man selbst die Meldungen für Ausnahmen definieren möchte, um sich diese Eigenschaften zunutze zu machen (z. B. falls der catch-Block nicht zwischen System-Ausnahmen und selbst definierten Ausnahmen unterscheidet) kann man den Error-Konstruktor benutzen.

Zum Beispiel:

function doSomethingErrorProne () { 
  if (ourCodeMakesAMistake()) {
    throw (new Error('Die Nachricht'));
  } else { 
    doSomethingToGetAJavascriptError(); 
  }
} 
.... 
try {
  doSomethingErrorProne(); 
} 
catch (e) { 
  alert(e.name); // Alarm-Meldung: 'Error'
  alert(e.message); // Alarm-Meldung: 'Eine Nachricht' oder eine JavaScript-Fehlermeldung) 
}

Quelltext der Version

<p>JavaScript unterstützt einen kompakten Satz von Anweisungen, die eingesetzt werden können, um Websites interaktiv zu gestalten. Dieses Kapitel bietet eine Übersicht zu diesen Anweisungen.</p>
<p>Jeder Ausdruck ist auch eine Anweisung. Das Kapitel <a href="/de/JavaScript/javascript_guide/Ausdr%C3%BCcke_und_Operatoren" title="/de/JavaScript/javascript_guide/Ausdr%C3%BCcke_und_Operatoren">Ausdrücke und Operatoren</a> stellt hierzu mehr Informationen bereit.</p>
<p>Zur Trennung von Anweisungen wird das Semikolon (;) verwendet. Die <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Statements" title="en-US/docs/JavaScript/Reference/Statements">JavaScript-Referenz</a> informiert darüber genauer.</p>
<h2 id="Blockstruktur">Blockstruktur</h2>
<p>Anweisungen werden durch Anweisungsblöcke gruppiert und zusammengefasst. Ein Anweisungsblock wird durch geschweifte Klammern festgelegt:</p>
<div style="margin-right:270px;">
  <pre class="brush: js">
{
   Anweisung_1;
   Anweisung_2;
   .
   .
   .
   Anweisung_n;
}
</pre>
</div>
<p><strong>Beispiel</strong><br />
  Anweisungsblöcke werden vorwiegend in Verbindung mit Anweisungen zur Flusskontrolle eingesetzt (z. B. <code>if</code>, <code>for</code>, <code>while</code>).</p>
<div style="margin-right:270px;">
  <pre class="brush: js">
while (x &lt; 10){
  x++;
}
</pre>
</div>
<p>Bei diesem Beispiel ist <code>{ x++; }</code> der Anweisungsblock.</p>
<p><strong>Wichtig</strong>: JavaScript grenzt die Sichtbarkeit (Scope) von Blöcken <strong>nicht</strong> ab. Variablen, die innerhalb eines Blocks deklariert werden, sind innerhalb der Funktion oder des Skripts sichtbar und bleiben auch innerhalb dieses Bereichs erhalten. Mit anderen Worten: Anweisungsblöcke erzeugen keinen seperaten Sichtbarkeitsbereich. Obwohl es auch eigenständige Blockanweisungen (standalone) gibt und diese zur Syntax gehören, sollte man auf deren Einsatz besser verzichten, da sie nicht auf dieselbe Weise funktionieren wie z. B. bei C oder Java.</p>
<p>Beispiel:</p>
<pre class="brush: js">
var x = 1;
{
  var x = 2;
}
alert(x); // Ausgabe: 2
</pre>
<p>Die Ausgabe ist hier <code>2</code>, weil sich die Anweisung <code>var x</code>, die sich innerhalb des Anweisungsblocks befindet im selben Sichtbarkeitsbereich liegt, wie die andere <code>var x</code>-Anweisung, die vor dem Anweisungsblock steht. Bei C oder Java wäre die Ausgabe <code>1</code>.</p>
<h2 id="Bedingte_Anweisungen">Bedingte Anweisungen</h2>
<p>Bei einer bedingten Anweisung wird ein Satz von Befehlen ausgeführt, wenn eine bestimmte festgelegte Bedingung erfüllt ist. JavaScript kennt hierfür zwei verschiedene Anweisungen: <code>if...else</code> und <code>switch</code>.</p>
<h3 id="if...else_Anweisung">if...else-Anweisung</h3>
<p>Die <code>if</code> Anweisung sollte eingesetzt werden, wenn bestimmte Anweisungen ausgeführt werden sollen, falls eine logische Bedingungen erfüllt ist. Zusätzlich kann ein optionaler <code>else</code>-Abschnitt festgelegt werden, dessen Anweisungen ausgeführt werden, falls die Bedingung nicht erfüllt ist. Die Syntax einer <code>if</code> Anweisung ist wie folgt:</p>
<pre class="brush: js">
if (Bedingung)
  Anweisung_1
[else
  Anweisung_2]
</pre>
<p>Die <code>Bedingung</code> kann jeder Ausdruck sein, der zu <code>true</code> oder <code>false</code> evaluiert. Wenn die <code>Bedingung</code> zu <code>true </code>ist, wird <code>Anweisung_1</code> ausgeführt, andernfalls wird <code>Anweisung_2</code> ausgeführt. <code>Anweisung_1</code> und<code> Anweisung_2</code> können für beliebige Anweisungen stehen, auch weitere verschachtelte <code>if</code>-Anweisungen könnten an dieser Stelle eingesetzt werden.</p>
<p>Darüber hinaus ist es mit Hilfe von <code>else if</code> möglich, mehrere Bedingungen nacheinander zu überprüfen (Verzweigung):&nbsp;&nbsp;</p>
<pre class="brush: js">
if (Bedingung)
  Anweisung_1
[else if (Bedingung_2)
  Anweisung_2]
...
[else if (Bedingung_n_1)
  Anweisung_n_1]
[else
  Anweisung_n]
</pre>
<p>Sollen mehrere Anweisungen ausgeführt werden, müssen sie innerhalb eines Anweisungsblocks (<code>{ ... }</code>) stehen. Es ist gute Praxis, die Blöcke immer angeben, auch wenn sie für einzelne Anweisungen nicht zwingend notwendig sind. Insbesondere bei verschachtelten <code>if</code>-Anweisungen wird hierdurch die Lesbarkeit verbessert.</p>
<pre class="brush: js">
if (condition) {
  statements_1
} else {
  statements_2
}
</pre>
<p>Auch ist es empfehlenswert keine Zuweisungen an der Stelle für die Bedingung vorzunehmen, weil diese aufgrund des Gleichzeichens leicht mit Vergleichen verwechselt werden können. Der folgende Code sollte also nicht verwendet werden:</p>
<pre class="brush: js">
if (x = y) {
  /* do the right thing */
}
</pre>
<p>Wenn man eine Zuweisung in einem bedingten Ausdruck vornehmen möchte, sollte diese in zusätzliche Klammern eingeschlossen werden. Zum Beispiel:</p>
<pre class="brush: js">
if ((x = y)) {
  /* mach das Richtige */
}
</pre>
<p>Die folgenden Werte evaluieren zu false:</p>
<ul>
  <li><code>false</code></li>
  <li><code>undefined</code></li>
  <li><code>null</code></li>
  <li><code>0</code></li>
  <li><code>NaN</code></li>
  <li>die leere Zeichenkette (<code>""</code>)</li>
</ul>
<p>Alle anderen Werte, einschließlich aller Objekte, evaluieren zu true, wenn sie als Bedingung angegeben werden.</p>
<p>Vorsicht: Die primitiven booleschen Werte wie <code>true</code> und <code>false</code> sollten nicht mit den Werten true und false des booleschen Objekts (Boolean) verwechselt werden.</p>
<p>Zum Beispiel:</p>
<pre class="brush: js">
var b = new Boolean(false);
if (b) // diese Bedingung evaluiert zu true
</pre>
<p><strong>Beispiel</strong></p>
<p>Beim folgenden Beispiel liefert die Funktion <code>checkData</code> den Wert <code>true</code>, wenn die Anzahl der Zeichen eines Text-Objekts dem Wert 3 entspricht. Andernfalls wird eine Alarm-Nachricht ausgegeben und <code>false</code> zurückgegeben.</p>
<pre class="brush: js">
function checkData() {
  if (document.form1.threeChar.value.length == 3) {
    return true;
  } else {
    alert("Bitte genau 3 Zeichen eingeben. " +
      document.form1.threeChar.value + " is not valid.");
    return false;
  }
}
</pre>
<h3 id="switch-Anweisung">switch-Anweisung</h3>
<p>Bei der <code>switch</code>-Anweisung wird ein Ausdruck ausgewertet und das Ergebnis mit den unterschiedlichen Ausdrücken der case-Labels verglichen (Fallunterscheidung). Stimmen die Werte überein, werden die Anweisungen des entsprechenden case-Abschnitts ausgeführt.</p>
<p>Beispiel:</p>
<pre class="brush: js">
switch (Ausdruck) {
   case Label_1:
      Anweisung_1
      [break;]
   case Label_2:
      Anweisung_2
      [break;]
   ...
   default:
      Anweisung_falls_keine_case_Ausdruck_passt
      [break;]
}
</pre>
<p>Bei diesem Skript wird zuerst nach einem <code>case</code>-Abschnitt gesucht dessen Wert mit dem Wert des in Klammern spezifizierten Ausdrucks übereinstimmt. Wird ein solcher Wert gefunden, werden die Anweisungen des <code>case</code>-Abschnitts ausgeführt. Sollte keiner der Werte mit dem Wert des Ausdrucks übereinstimmen, wird nach einem <code>default</code>-Abschnitt gesucht und falls vorhanden, die Kontrolle an diesen übergeben und die entsprechenden Anweisungen ausgeführt. Falls kein default-Abschnitt vorhanden ist, wird die Ausführung hinter der <code>switch</code>-Anweisung fortgesetzt. Dem Standard nach sollte der default-Abschnitt an letzter Stelle stehen, jedoch ist er keine Pflicht.</p>
<p>Die optionale <code>break</code>-Anweisung innerhalb jedes case-Abschnitts bewirkt den Abbruch der switch-Anweisung. Die Ausführung wird dann hinter der <code>switch</code>-Anweisung fortgesetzt. Wenn <code>break</code> nicht angegeben ist, findet kein Abbruch statt und die Anweisungen folgender case-Abschnitte werden ebenfalls ausgeführt, falls deren Label-Wert mit dem Wert des Ausdrucks übereinstimmt.</p>
<p><strong>Beispiel</strong><br />
  Beim folgenden Beispielcode evaluiert <code>fruittype</code> zu "Bananen". Daraufhin wird eine Übereinstimmung beim <code>case</code>-Abschnitt "Bananen" gefunden und die Anweisungen dieses Abschnitts werden ausgeführt. Anschließend wird die <code>switch</code>-Anweisung an der Stelle des <code>break</code> verlassen und die Ausführung hinter dem <code>switch</code>-Block fortgesetzt. Wenn kein <code>break</code> innerhalb des Bananen-Abschnitts angegeben wäre, würde der Abschnitt "Kirschen" ebenfalls (bis zu <code>break</code>) ausgeführt werden.</p>
<pre class="brush: js">
switch (fruittype) {
   case "Orangen":
      document.write("Orangen kosten 0.59 EUR das Pfund.&lt;br&gt;");
      break;
   case "Birnen":
      document.write("Birnen kosten 0.32 EUR das Pfund.&lt;br&gt;");
      break;
   case "Bananen":
      document.write("Bananen kosten  0.48 EUR das Pfund.&lt;br&gt;");
      break;
   case "Kirschen":
      document.write("Kirschen kosten 3.00 EUR das Pfund.&lt;br&gt;");
      break;
   case "Mangos":
   case "Papayas":
      document.write("Mangos und Papayas kosten 2.79 EUR das Pfund.&lt;br&gt;");
      break;
   default:
      document.write("Entschuldigung, " + fruittype + "sind ausverkauft.&lt;br&gt;");
}
document.write("Darf es sonst noch etwas sein?&lt;br&gt;");</pre>
<h2 id="Schleifen-Anweisungen">Schleifen-Anweisungen</h2>
<p>Eine Schleife ist ein Satz von Befehlen, die solange wiederholt ausgeführt werden, bis eine bestimmte Bedingung erfüllt ist. Javascript unterstützt die Anweisungen <code>for</code>, <code>do while</code> und <code>while</code>, sowie Labels (Labels sind nicht direkt eine Schleifenanweisung, werden aber sehr oft mit diesen zusammen verwendet). Zusätzlich können die beiden Anweisungen <code>break</code> und <code>continue</code> zum Einsatz kommen.</p>
<p>Eine weitere Anweisung ist <code>for...in</code>, welche ebenfalls wiederholt Anweisungen ausführt, jedoch zur Manipulation von Objekten verwendet wird. Siehe {{ linkToFragment("Object Manipulation Statements") }}.</p>
<p>Die Schleifen-Anweisungen sind:</p>
<ul>
  <li>{{ linkToFragment("for-Anweisung") }}</li>
  <li>{{ linkToFragment("do...while-Anweisung") }}</li>
  <li>{{ linkToFragment("while-Anweisung") }}</li>
  <li>{{ linkToFragment("label-Anweisung") }}</li>
  <li>{{ linkToFragment("break-Anweisung") }}</li>
  <li>{{ linkToFragment("continue-Anweisung") }}</li>
</ul>
<h3 id="for-Anweisung">for-Anweisung</h3>
<p>Eine <code>for</code>-Schleife führt wiederholt Anweisungen aus, bis eine festgelegte Bedingung zu false evaluiert. Die Syntax der for-Schleife ist ähnlich wie bei Java und C:</p>
<pre class="brush: js">
for ([Initialisierungsausdruck]; [Bedingung]; [Inkrementierungsausdruck])
   Anweisung
</pre>
<p>Wenn eine <code>for</code>-Schleife ausgeführt wird, passiert folgendes:</p>
<ol>
  <li>Der <code>Initialisierungsausdruck </code>wird (falls angegeben) ausgeführt. Der Ausdruck initialisiert für gewöhnlich eine oder mehrere einfache Variablen, die zur Schleifenzählung verwendet werden. Die Syntax erlaubt jedoch Anweisungen beliebiger Komplexität. Auch Variablen-Zuweisungen sind erlaubt.</li>
  <li>Der Ausdruck <code>Bedingung</code> wird ausgewertet. Wenn der Wert <code>true</code> ist, wird die <code>Anweisung</code> ausgeführt. Wenn der Wert der<code> Bedingung</code> <code>false</code> ist, wird die Schleife abgebrochen. Fehlt der Ausdruck <code>Bedingung</code> komplett, wird angenommen, dass der Wert der <code>Bedingung</code> <code>true</code> ist.</li>
  <li>Die <code>Anweisung</code> wird ausgeführt. Bei mehreren Anweisungen muss eine Blockanweisung (<code>{ ... }</code>) zur Gruppierung verwendet werden.</li>
  <li>Der <code>Inkrementierungsausdruck</code> (üblicherweise wird die Zählvariable inkrementiert), falls angegeben, wird ausgeführt und der nächste Schleifendurchlauf gestartet (Schritt 2). Dies wird solange wiederholt, bis die <code>Bedingung</code> nicht mehr erfüllt ist.</li>
</ol>
<p><strong>Beispiel</strong></p>
<p>Die Funktion im folgenden Code enthält eine <code>for</code>-Schleife, welche die Anzahl der ausgewählten Optionen in einer Liste zählt. Die <code>for</code>-Schleife deklariert die Variable <code>i</code> und initialisiert sie mit dem Wert <code>0</code>. Die Schleife überprüft, ob <code>i</code> kleiner ist als die Anzahl der verfügbaren Optionen des <code>select</code>-Objekts, welches die Auswahl mehrerer Optionen erlaubt. Solange dies zutrifft wird wiederholt der Anweisungsblock mit der if-Anweisung ausgeführt und der Wert der Variablen <code>i</code> nach jedem Schleifendurchlauf um <code>1</code> erhöht.</p>
<pre class="brush: html">
&lt;script type="text/javascript"&gt;

function howMany(selectObject) {
   var numberSelected = 0;
   for (var i = 0; i &lt; selectObject.options.length; i++) {
      if (selectObject.options[i].selected)
         numberSelected++;
   }
   return numberSelected;
}

&lt;/script&gt;
&lt;form name="selectForm"&gt;
   &lt;p&gt;
      &lt;strong&gt;Choose some music types, then click the button below:&lt;/strong&gt;
      &lt;br/&gt;
      &lt;select name="musicTypes" multiple="multiple"&gt;
         &lt;option selected="selected"&gt;R&amp;B&lt;/option&gt;
         &lt;option&gt;Jazz&lt;/option&gt;
         &lt;option&gt;Blues&lt;/option&gt;
         &lt;option&gt;New Age&lt;/option&gt;
         &lt;option&gt;Classical&lt;/option&gt;
         &lt;option&gt;Opera&lt;/option&gt;
      &lt;/select&gt;
   &lt;/p&gt;
   &lt;p&gt;
      &lt;input type="button" value="How many are selected?"
         onclick="alert ('Number of options selected: ' + howMany(document.selectForm.musicTypes))"/&gt;
   &lt;/p&gt;
&lt;/form&gt;</pre>
<h3 id="do...while_Anweisung">do...while Anweisung</h3>
<p>Bei der <code>do...while</code>-Anweisung wird die Ausführung solange wiederholt bis eine bestimmte Bedingung zu <code>false</code> evaluiert. Die Syntax einer <code>do...while</code>-Anweisung ist wie folgt:</p>
<pre class="brush: js">
do
   Anweisung
while (Bedingung);
</pre>
<p>Die Anweisung wird einmal ausgeführt bevor die Bedingung überprüft wird. Um mehrere Anweisungen auszuführen, muss eine Blockanweisung zur Gruppierung eingesetzt werden. Wenn der Wert der Bedingung <code>true</code> ist, wird die Anweisung erneut ausgeführt. Die Bedingung wird nach jedem Durchlauf überprüft und die Schleife abgebrochen, wenn die Bedingung nicht mehr erfüllt ist.</p>
<p><strong>Beispiel</strong></p>
<p>Beim folgenden Beispiel wird zuerst ein Schleifendurchlauf durchgeführt. Anschließend wird die Bedingung überprüft und solange weitere Schleifendurchläufe durchgeführt, bis i nicht mehr kleiner als 5 ist.</p>
<pre class="brush: js">
do {
   i += 1;
   document.write(i);
} while (i &lt; 5);</pre>
<h3 id="while-Anweisung">while-Anweisung</h3>
<p>Eine <code>while</code>-Anweisung führt Anweisungen solange wiederholt aus wie eine bestimmte Bedingung zu true evaluiert. Eine while Anweisung sieht wie folgt aus:</p>
<pre class="brush: js">
while (Bedingung)
   Anweisung
</pre>
<p>Wenn die Bedingung nicht mehr erfüllt ist, stoppt die Ausführung der Anweisung und die Ausführung wird hinter der Schleife fortgesetzt.</p>
<p>Die Bedingung wird gleich zu Beginn vor der Ausführung der Anweisung überprüft. Wenn die Bedingung erfüllt ist, wird die Anweisung ausgeführt und die Bedingung erneut überprüft. Wenn die Bedingung nicht erfüllt ist, wird die Schleife abgebrochen und die Ausführung hinter der Schleife fortgesetzt.</p>
<p>Auch bei der <code>while</code>-Schleife müssen mehrere Anweisungen durch einen Anweisungsblock <code>({ ... })</code> gruppiert werden.</p>
<p><strong>Beispiel 1</strong></p>
<p>Die folgende <code>while</code>-Schleife wird ausgeführt, solange n kleiner als 3 ist:</p>
<pre class="brush: js">
n = 0;
x = 0;
while (n &lt; 3) {
   n++;
   x += n;
}</pre>
<p>Mit jeder Iteration wird die Variable <code>n</code> inkrementiert und der Wert zu <code>x</code> hinzuaddiert. Daher nehmen <code>x</code> und <code>n</code> im Verlauf die folgenden Werte an:</p>
<ol>
  <li>Nach dem ersten Durchlauf: n = 1 und x = 1</li>
  <li>Nach dem zweiten Durchlauf: n = 2 und x = 3</li>
  <li>Nach dem dritten Durchlauf: n = 3 und x = 6</li>
</ol>
<p>Nachdem der dritte Durchlauf abgeschlossen ist, ist die Bedingung <code>n &lt; 3</code> nicht mehr erfüllt und die Schleife wird abgebrochen.</p>
<p><strong>Beispiel 2</strong></p>
<p>Man sollte unbedingt darauf achten, keine Endlos-Schleifen zu programmieren, also sicherstellen, dass die Bedingung früher oder später nicht mehr erfüllt ist, sodass die Schleife abbricht. Die Anweisungen des folgenden Codes werden unendlich wiederholt ausgeführt, weil die Bedingung niemals zu <code>false</code> evaluiert:</p>
<pre class="brush: js">
while (true) {
   alert("Hello, world");
}</pre>
<h3 id="Label-Anweisungen">Label-Anweisungen</h3>
<p>Ein Label ist ein Bezeichner, der eine Stelle markiert, die als Sprungziel dient. Zum Beispiel kann mit einem Label eine Schleife markiert und anschließend mit Hilfe von <code>break</code> oder <code>continue</code> die Schleife unterbrochen oder beim nächsten Durchlauf fortgesetzt werden.</p>
<p>Syntax:</p>
<pre class="brush: js">
Label :
   Anweisung
</pre>
<p><br />
  Der Wert von <em>Label </em>kann ein JavaScript-Bezeichner sein, der jedoch keines der reservierten Wörter von JavaScript sein darf. <code>Anweisung</code> kann für beliebige Anweisungen stehen.</p>
<p><strong>Beispiel</strong><br />
  Bei diesem Beispiel markiert das Label <code>markLoop</code> eine <code>while</code>-Schleife:</p>
<pre class="brush: js">
markLoop:
while (theMark == true) {
   doSomething();
}</pre>
<h3 id="break-Anweisung">break-Anweisung</h3>
<p>Die break-Anweisung wird&nbsp; in Verbindung mit Schleifen, switch-Anweisungen oder mit Labels zum Abbruch eingesetzt.</p>
<ul>
  <li>Wenn break ohne ein Label verwendet wird, terminiert es das innerste while, do-while, for, oder switch und gibt die Kontrolle an die dahinterstehende Anweisung weiter.</li>
  <li>Wenn break mit einem Label eingesetzt wird, terminiert es die angegebende Label-Anweisung.</li>
</ul>
<p>Die Syntax von break-Anweisungen ist wie folgt:</p>
<ol>
  <li><code>break;</code></li>
  <li><code>break <em>Label</em>;</code></li>
</ol>
<p>Die erste Form terminiert die innerste Schleife oder switch-Anweisung. Die zweite Form terminiert die angegebene Label-Anweisung.</p>
<p><br />
  <strong>Beispiel 1:</strong><br />
  Beim folgenden Beispiel wird solange über die Elemente eines Arrays iteriert, bis der index eines Elements gefunden wird, dessen Wert <code>derWert</code> entspricht:</p>
<pre class="brush: js">
for (i = 0; i &lt; a.length; i++) {
   if (a[i] == derWert)
      break;
}</pre>
<p><strong>Beispiel 2: </strong>Abbruch und Sprung zu einem Label</p>
<pre class="brush: js">
var x = 0;
var z = 0
labelCancelLoops: while (true) {
    console.log("Outer loops: " + x);
    x += 1;
    z = 1;
    while (true) {
        console.log("Inner loops: " + z);
        z += 1;
        if (z === 10 &amp;&amp; x === 10) {
            break labelCancelLoops;
        } else if (z === 10) {
            break;
        }
    }
}
</pre>
<h3 id="continue-Anweisung">continue-Anweisung</h3>
<p>Mit der <code>continue</code>-Anweisung wird ein Sprung zum nächsten Schleifendurchlauf veranlasst.</p>
<ul>
  <li>Wenn <code>continue</code> ohne ein Label eingesetzt wird, bricht es den aktuellen Durchlauf der innersten <code>while-</code>, <code>do-while-</code> oder<code> for-</code>Anweisung ab und die Ausführung wird bei der nächsten Iteration fortgesetzt. Im Gegensatz zu <code>break</code> wird bei <code>continue</code> die Schleife nicht komplett abgebrochen, sondern nur der aktuelle Durchlauf der Schleife. Bei einer <code>while</code>-Schleife wird ein Sprung zurück zur Bedingung durchgeführt. Bei einer <code>for</code>-Schleife bewirkt <code>continue</code> einen Sprung zum Inkrementierungsausdruck.</li>
  <li>Steht nach <code>continue</code> ein Label, bewirkt es einen Sprung zu diesem Label.</li>
</ul>
<p><br />
  Die Syntax der <code>continue</code>-Anweisung ist wie folgt:</p>
<ol>
  <li><code>continue</code></li>
  <li><code>continue </code><em><code>Label</code></em></li>
</ol>
<p><strong>Beispiel 1</strong><br />
  Das folgende Beispiel zeigt eine <code>while</code>-Schleife mit einer <code>continue</code>-Anweisung, die ausgeführt wird, wenn <code>i</code> den Wert <code>3</code> besitzt. Im Verlauf der Ausführung nimmt <code>n</code> die Werte <code>1</code>, <code>3</code>, <code>7</code> und <code>12</code> an.</p>
<pre class="brush: js">
i = 0;
n = 0;
while (i &lt; 5) {
   i++;
   if (i == 3)
      continue;
   n += i;
}
</pre>
<p><strong>Beispiel 2</strong><br />
  Eine Anweisung mit dem Label <code>checkiandj</code> enthält eine weitere Anweisung mit dem Label <code>checkj</code>. Wenn <code>continue</code> erreicht ist, bricht das Skript die aktuelle Iteration von <code>checkj</code> ab und startet die nächste Iteration. Jedes Mal, wenn <code>continue</code> erreicht ist, wird <code>checkj</code> erneut durchlaufen, solange bis die Bedingung der <code>if</code>-Anweisung zu <code>false</code> evaluiert. Wenn <code>false</code> zurückgegeben wird, wird der Rest des Codes von <code>checkiandj</code> bis zum Ende ausgeführt und <code>checkiandj</code> wiederholt, bis die zugehörige Bedingung zu <code>false</code> evaluiert. Wenn <code>false</code> zurückgegeben wird, wird die Ausführung bei der Anweisung hinter <code>checkiandj</code> fortgesetzt.</p>
<p>Wenn bei <code>continue</code> das Label <code>checkiandj</code> angegeben wäre, würde das Skript am Anfang der <code>checkiandj</code>-Anweisung fortgesetzt.</p>
<pre class="brush: js">
checkiandj :
   while (i &lt; 4) {
      document.write(i + "&lt;br/&gt;");
      i += 1;
      checkj :
         while (j &gt; 4) {
            document.write(j + "&lt;br/&gt;");
            j -= 1;
            if ((j % 2) == 0)
               continue checkj;
            document.write(j + " is odd.&lt;br/&gt;");
         }
      document.write("i = " + i + "&lt;br/&gt;");
      document.write("j = " + j + "&lt;br/&gt;");
   }</pre>
<h2 id="Anweisungen_zur_Objekt-Manipulation">Anweisungen zur Objekt-Manipulation</h2>
<p>JavaScript benutzt die Anweisungen for...in, for each...in, und with zur Manipulation von Objekten.</p>
<h3 id="for...in-Anweisung">for...in-Anweisung</h3>
<p>Die Anweisung <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Statements/for...in" title="en-US/docs/JavaScript/Reference/Statements/for...in"><code>for...in</code></a> iteriert eine bestimmte Variable über alle Eigenschaften eines Objekts. Bei jedem Schleifendurchlauf wird <code>Variable</code> der Name der Eigenschaft zugewiesen. Die <code>Anweisungen</code> werden für jede vorhandene Eigenschaft einmal ausgeführt.</p>
<p>Syntax:</p>
<pre class="brush: js">
for (Variable in Objekt) {
   Anweisungen
}
</pre>
<p><strong>Beispiel</strong><br />
  Die folgende Funktion nimmt ein Objekt als Argument und den Namen des Objekts entgegen. Anschließend wird mit Hilfe von <code>for...in</code> über alle Objekteigenschaften iteriert und ein String mit dem Namen und dem Wert der Eigenschaft zurückgegeben.</p>
<pre class="brush: js">
function dump_props(obj, obj_name) {
   var result = "";
   for (var i in obj) {
      result += obj_name + "." + i + " = " + obj[i] + "&lt;br&gt;";
   }
   result += "&lt;hr&gt;";
   return result;
}
</pre>
<p>Bei einem Objekt <code>automobil</code> mit den Eigenschaften <code>hersteller </code>und <code>modell</code> wäre das Ergebnis:</p>
<pre class="brush: js">
automobil.hersteller = Ford
automobil.modell = Mustang
</pre>
<p><strong>Arrays</strong></p>
<p>Obwohl es sinnvoll erscheinen mag, eine <code>for...in</code>-Anweisung zu benutzen, um über die Elemente eines Arrays zu iterieren, weil die <code>for...in</code>-Anweisung zusätzlich zu den Array-Elementen auch benutzerdefinierte Eigenschaften und Methoden erfasst, sollte besser eine normale <code>for</code>-Schleife benutzt werden, um über Array-Elemente zu interieren, da bei benutzerdefinierten Methoden nicht nur ein numerischer Index, sondern auch der Name der benutzerdefinierten Eigenschaften oder Methoden zurückgegeben wird.</p>
<h3 id="for_each...in_Anweisung">for each...in Anweisung</h3>
<p><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Statements/for_each...in" title="en-US/docs/JavaScript/Reference/Statements/for each...in"><code>for each...in</code></a> ist eine Schleifenanweisung, die mit <a href="https://developer.mozilla.org/en-US/docs/JavaScript/New_in_JavaScript/1.6" title="en-US/docs/JavaScript/New in JavaScript/1.6">JavaScript 1.6 </a>eingeführt wurde. Sie ist ähnlich wie <code>for...in</code>, aber iteriert über die Werte von Objekt-Eigenschaften und nicht über die Namen.</p>
<pre class="brush: js">
var sum = 0;
var obj = {prop1: 5, prop2: 13, prop3: 8};
for each (var item in obj) {
  sum += item;
}
print(sum); // gibt 26 aus, also die Summe von 5+13+8</pre>
<h2 id="Kommentare">Kommentare</h2>
<p>Kommentare sind Bemerkungen der Autorin/des Autors, welche die Funktion von Code beschreiben. Kommentare werden vom Interpreter ignoriert. JavaScript unterstützt die Syntax für Kommentare im Stil von Java und C++:</p>
<ul>
  <li>Einzeilige Kommentare werden durch doppelte Schrägstriche (//) eingeleitet.</li>
  <li>Kommentare über mehrere Zeilen werden in /* und */ eingeschlossen.</li>
</ul>
<p><strong>Beispiel</strong><br />
  Der folgende Code demonstriert die beiden Varianten zur Kennzeichnung von Kommentaren:</p>
<pre class="brush: js">
// Dies ist ein einzeiliger Kommentar.

/* Dies ist ein mehrzeiliger Kommentar. 
Er kann sich über beliebig viele Zeilen erstrecken 
und beliebige Zeichen enthalten. */</pre>
<h2 id="Anweisung_zur_Ausnahmebehandlung">Anweisungen zur Ausnahmebehandlung (Exceptions)</h2>
<p>Mit der Anweisung <code>throw</code> wird eine Ausnahmenbehandlung eingeleitet und Werte von Ausdrücken <em>ausgeworfen</em>. Außerdem lässt sich mit Hilfe der <code>try...catch</code>-Anweisung auf Ausnahmen reagieren.</p>
<p>Mit try...catch können auch Java-Ausnahmen behandelt werden (Vorsicht: {{ bug("391642") }} ). Unter <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/LiveConnect_Overview#Handling_Java_Exceptions_in_JavaScript" title="en-US/docs/JavaScript/Guide/LiveConnect Overview#Handling Java Exceptions in JavaScript">Handling Java Exceptions in JavaScript</a> und <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/LiveConnect_Overview#JavaScript_to_Java_Communication" title="en-US/docs/JavaScript/Guide/LiveConnect Overview#JavaScript to Java Communication">JavaScript to Java Communication</a> wird genauer auf das Thema eingegangen.</p>
<ul>
  <li>{{ linkToFragment("throw Statement") }}</li>
  <li>{{ linkToFragment("try...catch Statement") }}</li>
</ul>
<h3 id="Typen_von_Ausnahmen">Typen von Ausnahmen</h3>
<p>Nahezu jedes Objekt kann in JavaScript ausgeworfen werden, jedoch werden nicht alle Objekte auf dieselbe Weise erstellt. Obwohl es üblich ist, dass Ziffern oder Zeichenketten als Error ausgeworfen werden, ist es weit mehr effektiver, einen der Ausnametypen zu benutzen, die speziell für diesen Zweck entwickelt wurden.</p>
<ul>
  <li><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects#Error_constructors">ECMAScript exceptions</a></li>
  <li><a href="https://developer.mozilla.org/en-US/docs/DOM/DOMException" title="en-US/docs/DOM/DOMException">DOMException</a></li>
  <li><a href="https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIXPCException" title="en-US/docs/nsIXPCException">nsIXPCException</a> (<a href="https://developer.mozilla.org/en-US/docs/XPConnect" title="en-US/docs/XPConnect">XPConnect</a>)</li>
</ul>
<h3 id="throw-Anweisung">throw-Anweisung</h3>
<p>Die throw-Anweisung wird eingesetzt, um eine Ausnahmebehandlung einzuleiten und einen Ausdruck auszuwerfen. Der Ausdruck, dessen Wert ausgeworfen werden soll, wird hinter <code>throw</code> angegeben:</p>
<pre class="brush: js">
throw Ausdruck;
</pre>
<p>Der Ausdruck muss nicht von einem speziellen Typ sein, sondern es kann jede Art von Ausdruck benutzt werden. Der folgende Code wirft verschiedene Ausnahmen mit unterschiedlichen Typen aus:</p>
<pre class="brush: js">
throw "Error2";
throw 42;
throw true;
throw {toString: function() { return "Ich bin ein Objekt!"; } };
</pre>
<div class="note">
  <strong>Note:</strong> Man kann beim Auswerfen von Ausnahmen auch Objekte angeben. Im Anschluss kann im <code>catch</code>-Block auf die Eigenschaften dieses Objekts zugegriffen werden. Beim folgenden Beispiel wird ein Objekt&nbsp;<code>myUserException</code> mit dem Typ <code>UserException</code> erstellt und dieses in einer <code>throw</code>-Anweisung benutzt.</div>
<pre class="brush: js">
// Erstellen eines Objekt-Typs UserException 
function UserException (message){
  this.message=message;
  this.name="UserException";
}

// Konvertieren der Ausnahme zu einem String,
// wenn sie als String benutzt wird (z .B. von der Error-Konsole)
UserException.prototype.toString = function (){
  return this.name + ': "' + this.message + '"';
}

// Erstellen einr Instanz des Objekt-Typs und Auswurf
throw new UserException("Value too high");</pre>
<h3 id="try...catch-Anweisung">try...catch-Anweisung</h3>
<p>Bei der <code>try...catch</code>-Anweisung wird ein Block von Anweisungen "ausprobiert" und auf gegebenenfalls auftretende Ausnahmen reagiert. Wenn eine Ausnahme ausgeworfen wird, wird sie von der <code>try...catch</code>-Anweisung abgefangen.</p>
<p>Die <code>try...catch</code>-Anweisung besteht aus einem <code>try</code>-Block, welcher eine oder mehrere Anweisungen enthält und einem oder mehreren catch-Blöcken, die Anweisungen enthalten und jeweils bestimmen, was beim Auftreten einer bestimmten Ausnahme getan werden soll. Man möchte in der Regel, dass der try-Block erfolgreich ausgeführt wird, doch falls Fehler auftreten, entsprechend mit den <code>catch</code>-Anweisungen darauf reagieren. Sobald eine Ausnahme durch den Code im <code>try</code>-Block (oder eine Funktion, die im try-Block ausgeführt wird) ausgelöst wurde, wird die Kontrolle an den catch-Block übergeben. Wenn keine Ausnahme im <code>try</code>-Block ausgelöst wird, wird der <code>catch</code>-Block nicht ausgeführt. Der <code>finally</code>-Block wird nach dem <code>try</code>- und catch-Block ausgeführt, jedoch bevor der Code nach dem <code>try...catch</code> ausgeführt wird. Mit dem <code>finally</code>-Block werden in der Regel Aufräumarbeiten durchgeführt.</p>
<p>Beim folgenden Beispiel kommt eine <code>try...catch</code>-Anweisung zur Anwendung. Es wird eine Funktion aufgerufen, die eine Zahl entgegen nimmt und anhand dieser einen Monatsnamen aus einem Array auswählt. Wenn der Wert keiner Monatszahl (1-12) entspricht, wird eine Ausnahme ausgelöst, welche den Wert <code>"InvalidMonthNo"</code> auswirft und die Anweisungen im <code>catch</code>-Block setzen die <code>monthName</code>-Variable auf <code>unknown</code>.</p>
<pre class="brush: js">
function getMonthName (mo) {
    mo=mo-1; // Adjust month number for array index (1=Jan, 12=Dec)
    var months=new Array("Jan","Feb","Mar","Apr","May","Jun","Jul",
          "Aug","Sep","Oct","Nov","Dec");
    if (months[mo] != null) {
       return months[mo]
    } else {
       throw "InvalidMonthNo"
    }
}

try {
// statements to try
    monthName=getMonthName(myMonth) // function could throw exception
}
catch (e) {
    monthName="unknown"
    logMyErrors(e) // pass exception object to error handler
}
</pre>
<h4 id="The_catch_Block" name="The_catch_Block">Der catch-Block</h4>
<p>Mit dem <code>catch</code>-Block kann jede Ausnahme, die im <code>try</code>-Block ausgelöst wird, abgefangen werden.</p>
<pre class="brush: js">
catch (catchID) {
  Anweisungen
}
</pre>
<p>Bei diesem <code>catch</code>-Block wurde ein Bezeichner <code>catchID</code> angegeben, welcher den Wert enthält, der von der <code>throw</code>-Anweisung ausgeworfen wird. Diesen Bezeichner kann man benutzen, um Informationen zu der ausgelösten Ausnahme zu erhalten. JavaScript erstellt diesen Bezeichner, wenn der catch-Block zur Ausführung kommt. Der Bezeichner bleibt nur für den catch-Block erhalten. Nachdem die Ausführung des catch-Blocks beendet ist, kann auf den Bezeichner nicht mehr zugegriffen werden.</p>
<p>Der folgende Code löst eine Ausnahme aus. Sobald die Ausnahme ausgelöst wird, wird der catch-Block ausgeführt.</p>
<pre class="brush: js">
try {
   throw "myException" // löst Ausnahme aus
}
catch (e) {
// Anweisungen um auf die Ausnahme zu reagieren
   logMyErrors(e) // Das Ausnahme-Objekt wird an eine Funktion übergeben
}
</pre>
<h4 id="Der_finally-Block">Der finally-Block</h4>
<p>Der finally-Block enthält Anweisungen, die nach den <code>try-</code> und <code>catch</code>-Blöcken ausgeführt werden, jedoch bevor der Code hinter der <code>try...catch</code>-Anweisung ausgeführt wird. Der Block wird unabhängig davon ausgeführt, ob eine Ausnahme ausgelöst wurde oder nicht. Auch wenn gar kein <code>catch</code>-Block vorhanden ist, womit auf eine Ausnahme reagiert wird, wird der <code>finally</code>-Block ausgeführt.</p>
<p>Mit Hilfe des finally-Blocks kann man elegant auf Fehler in einem Skript reagieren. Zum Beispiel möchte man vielleicht Ressourcen wieder freigeben, die das Skript in Anspruch genommen hat, bevor ein Abbruch stattfindet. Beim folgenden Beispiel wird eine Datei geöffnet und Anweisungen ausgeführt, die mit der Datei arbeiten (serverseitiges Javascript erlaubt den Zugriff auf Dateien). Wenn eine Ausnahme ausgelöst wird während die Datei geöffnet ist, schließt der Code des finally-Blocks die Datei, bevor die Ausführung des Skripts abbricht.</p>
<pre class="brush: js">
openMyFile();
try {
    writeMyFile(theData); // Hier könnte ein Fehler passieren
}catch(e){
    handleError(e); // Fehlerbehandlung falls Fehler auftritt
}finally {
    closeMyFile(); // In jedem Fall Datei schließen
}
</pre>
<p>Wenn der finally-Block einen Wert zurückgibt, ist dieser Wert der return-Wert des kompletten try-catch-finally-Blocks, unabhängig davon welche return-Werte die Funktionen in den try- und catch-Blöcken zurückgeben.</p>
<pre class="brush: js">
function f() {
    try {
        alert(0);
        throw "bogus";
    } catch(e) {
        alert(1);
        return true; // Dieser return-Wert wird zurückgehalten bis der finally-Block ausgeführt wurde
        alert(2); // nicht erreichbar
    } finally {
        alert(3);
        return false; // überschreibt das vorherige "return"
        alert(4); // nicht erreichbar
    }
    // "return false" wird nun ausgeführt
    
    alert(5); // nicht erreichbar
}
f(); // alert-Meldungen: 0, 1, 3 und "return false" wird ausgeführt
</pre>
<h4 id="Nesting_try...catch_Statements" name="Nesting_try...catch_Statements">Verschachteln von try...catch-Anweisungen</h4>
<p>Man kann eine oder mehrere <code>try...catch</code>-Anweisungen verschachteln. Wenn eine innere <code>try...catch</code>-Anweisungen keinen <code>catch</code>-Block hat, wird die einschließende <code>try-catch</code>-Anweisung auf eine Übereinstimmung überprüft.</p>
<h3 id="Einsatz_von_Error-Objekten">Einsatz von Error-Objekten</h3>
<p>Je nach Art des Fehlers kann es möglich sein, dass auf die Eigenschaften "name" und "message" zugegriffen werden kann, um detaillierte Informationen zu erhalten. Die Eigenschaft "name" enthält die Fehlerklasse (z. B. "DOMException" oder "Error") und die Eigenschaft "message" in der Regel genauere Informationen, als wenn man nur das Error-Objekt zu einem String konvertiert.</p>
<p>Wenn man selbst die Meldungen für Ausnahmen definieren möchte, um sich diese Eigenschaften zunutze zu machen (z. B. falls der catch-Block nicht zwischen System-Ausnahmen und selbst definierten Ausnahmen unterscheidet) kann man den Error-Konstruktor benutzen.</p>
<p>Zum Beispiel:</p>
<pre class="brush: js">
function doSomethingErrorProne () { 
  if (ourCodeMakesAMistake()) {
    throw (new Error('Die Nachricht'));
  } else { 
    doSomethingToGetAJavascriptError(); 
  }
} 
.... 
try {
  doSomethingErrorProne(); 
} 
catch (e) { 
  alert(e.name); // Alarm-Meldung: 'Error'
  alert(e.message); // Alarm-Meldung: 'Eine Nachricht' oder eine JavaScript-Fehlermeldung) 
}</pre>
Zu dieser Version zurücksetzen