Anweisungen (Kontrollfluss)

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

Inhalt der Version

JavaScript unterstützt einen kompakten Satz von Anweisungen, die eingesetzt werden, 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 mit Anweisungsblöcken gruppiert. Ein Anweisungsblock wird mit 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" innerhalb des Blocks im selben Sichtbarkeitsbereich befindet, wie die andere "var x"- Anweisung, die vor dem Block steht. Bei C oder Java wäre die Ausgabe "1".

Bedingte Anweisungen

Eine bedingte Anweisung ist ein Satz von Befehlen, die ausgeführt werden, 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. Ferner 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]

Bedingung kann jeder Ausdruck sein, der zu true oder false evaluiert. Wenn die Bedingung zu true evaluiert, 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 anzugeben, 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
}

Außerdem 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 angeben möchte, ist es gängige Praxis diese in zusätzliche Klammern einzuschließen. Zum Beispiel:

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

Die folgenden Werte evaluieren zu false:

  • false
  • undefined
  • null
  • 0
  • NaN
  • the empty string ("")

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 true, wenn die Anzahl der Zeichen eines Text-Objekts "3" ist. Andernfalls wird eine Alarm-Nachricht gezeigt 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

Eine switch Anweisung erlaubt einem Skript einen Ausdruck auszuwerten und das Ergebnis mit den Ausdrücken der case-Labels zu vergleichen (Fallunterscheidung). Stimmt das Ergebnis überein, werden die entsprechenden Anweisungen 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-Blocks 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. Der Konvention nach sollte der default-Abschnitt an letzter Stelle stehen, jedoch ist dieser Abschnitt 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 auch kein Abbruch statt und somit werden die Anweisungen folgender case-Abschnitte ebenfalls ausgeführt, falls der Label-Wert mit dem Ausdruck ü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 für die Manipulation von Objekten eingesetzt 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 Befehle aus, bis eine festgelegte Bedingung zu false evaluiert. Der JavaScript-Code der for-Schleife ist ähnlich wie bei Java und C. Eine for-Schleife sieht wie folgt aus:

for ([InitialAusdruck]; [Bedingung]; [InkrementAusdruck])
   Anweisung

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

  1. Der Initialisierungs-Ausdruck InitialAusdruck, 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 die Bedingung false ist, wird die Schleife abgebrochen. Fehlt der Ausdruck Bedingung komplett, wird angenommen, dass die Bedingung true ist.
  3. Die Anweisung wird ausgeführt. Bei mehreren Anweisungen muss eine Blockanweisung ({ ... }) zur Gruppierung verwendet werden.
  4. Der InkrementAusdruck (üblicherweise wird hier 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 folgende Funktion 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. Sie stellt sicher, dass i kleiner ist als die Anzahl der verfügbaren Optionen des Select-Objekts (welche die Auszahl mehrerer Optionen erlaubt), führt den Anweisungsblock mit der if-Anweisung aus und erhöht die Variable i nach jedem Schleifendurchlauf um eins.

<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

Die do...while Anweisung wiederholt die Ausführung solange bis eine bestimmte Bedingung zu false evaluiert. Eine do...while-Anweisung sieht wie folgt aus:

do
   statement
while (condition);

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 die Bedingung true ist, wird die Anweisung erneut ausgeführt. Die Bedingung wird nach jedem Durchlauf überprüft. Wenn die Bedingung nicht mehr erfüllt ist, wird die Schleife abgebrochen und die Ausführung dahinter fortgesetzt.

Beispiel

Beim folgenden Beispiel wird mindestens ein Schleifendurchlauf ausgeführt und dies sooft wiederholt 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 aus bis 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 hier 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, also wird die Schleife abgebrochen.

Beispiel 2

Man sollte darauf achten, dass man keine Endlos-Schleifen programmiert, 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 ein Bezeichner verwendet werden, um eine Schleife zu markieren, und anschließend mit Hilfe von break oder continue veranlasst werden, dass die Schleife unterbrochen oder beim nächsten Durchlauf fortgesetzt wird.

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 spezifizierte 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 es einen Sprung zum Inkrementierungs-Ausdruck.
  • 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 eins, drei, sieben und zwölf 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 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 false liefert. Wenn false zurückgegeben wird, wird der Rest der Anweisung checkiandj bis zum Ende ausgeführt und checkiandj wiederholt, bis die zugehörige Bedingung false liefert. Wenn false zurückgegeben wird, wird die Ausführung bei der Anweisung hinter checkiandj fortgesetzt.

Wenn continue ein Label checkiandj hätte, 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. Für jede vorhandene Eigenschaft eines Objekts werden die Anweisungen ausgeführt.

Syntax:

for (Variable in Objekt) {
   Anweisungen
}

Beispiel
Die folgende Funktion nimmt ein Objekt als Argument und den Namen des Objekts entgegen. Es wird dann über alle Objekteigenschaften iteriert und ein String mit den Namen der Eigenschaften und den Werten 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 auto mit den Eigenschaften hersteller und modell wäre das Ergebnis:

auto.hersteller = Ford
auto.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 benutzerdefinierte 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); // prints "26", which is 5+13+8

Kommentare

Kommentare sind Bemerkungen des Programm-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 Angabe von Kommentaren:

// Dies ist ein einzeiliger Kommentar.

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

Anweisung zur Ausnahmebehandlung

Mit der Anweisung throw können Ausnahmen eingeleitet und Werte von Ausdrücken ausgeworfen werden. 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. Während es Gang und Gäbe ist Numbers oder Strings als Error auszuwerfen, 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. Beim Auswerfen eines Ausnahme-Ausdrucks, gibt man den Ausdruck mit dem Wert an, der ausgeworfen werden soll:

throw Ausdruck;

Es kann jede Art von Ausdruck benutzt werden, nicht nur Ausdrücke eines speziellen Typs. 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 Objekte angeben. Anschließend kann im catch-Block auf die Eigenschaften des 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

#######

 

The try...catch statement marks a block of statements to try, and specifies one or more responses should an exception be thrown. If an exception is thrown, the try...catch statement catches it.

The try...catch statement consists of a try block, which contains one or more statements, and zero or more catch blocks, containing statements that specify what to do if an exception is thrown in the try block. That is, you want the try block to succeed, and if it does not succeed, you want control to pass to the catch block. If any statement within the try block (or in a function called from within the try block) throws an exception, control immediately shifts to the catch block. If no exception is thrown in the try block, the catch block is skipped. The finally block executes after the try and catch blocks execute but before the statements following the try...catch statement.

The following example uses a try...catch statement. The example calls a function that retrieves a month name from an array based on the value passed to the function. If the value does not correspond to a month number (1-12), an exception is thrown with the value "InvalidMonthNo" and the statements in the catch block set the monthName variable to 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
}

The catch Block

You can use a catch block to handle all exceptions that may be generated in the try block.

catch (catchID) {
  statements
}

The catch block specifies an identifier (catchID in the preceding syntax) that holds the value specified by the throw statement; you can use this identifier to get information about the exception that was thrown. JavaScript creates this identifier when the catch block is entered; the identifier lasts only for the duration of the catch block; after the catch block finishes executing, the identifier is no longer available.

For example, the following code throws an exception. When the exception occurs, control transfers to the catch block.

try {
   throw "myException" // generates an exception
}
catch (e) {
// statements to handle any exceptions
   logMyErrors(e) // pass exception object to error handler
}

The finally Block

The finally block contains statements to execute after the try and catch blocks execute but before the statements following the try...catch statement. The finally block executes whether or not an exception is thrown. If an exception is thrown, the statements in the finally block execute even if no catch block handles the exception.

You can use the finally block to make your script fail gracefully when an exception occurs; for example, you may need to release a resource that your script has tied up. The following example opens a file and then executes statements that use the file (server-side JavaScript allows you to access files). If an exception is thrown while the file is open, the finally block closes the file before the script fails.

openMyFile();
try {
    writeMyFile(theData); //This may throw a error
}catch(e){
    handleError(e); // If we got a error we handle it
}finally {
    closeMyFile(); // always close the resource
}

If the finally block returns a value, this value becomes the return value of the entire try-catch-finally production, regardless of any return statements in the try and catch blocks:

function f() {
    try {
        alert(0);
        throw "bogus";
    } catch(e) {
        alert(1);
        return true; // this return statement is suspended until finally block has completed
        alert(2); // not reachable
    } finally {
        alert(3);
        return false; // overwrites the previous "return"
        alert(4); // not reachable
    }
    // "return false" is executed now
    
    alert(5); // not reachable
}
f(); // alerts 0, 1, 3; returns false

Nesting try...catch Statements

You can nest one or more try...catch statements. If an inner try...catch statement does not have a catch block, the enclosing try...catch statement's catch block is checked for a match.

Utilizing Error objects

Depending on the type of error, you may be able to use the 'name' and 'message' properties to get a more refined message. 'name' provides the general class of Error (e.g., 'DOMException' or 'Error'), while 'message' generally provides a more succinct message than one would get by converting the error object to a string.

If you are throwing your own exceptions, in order to take advantage of these properties (such as if your catch block doesn't discriminate between your own exceptions and system ones), you can use the Error constructor. For example:

function doSomethingErrorProne () {
   if (ourCodeMakesAMistake()) {
      throw (new Error('The message'));
   }
   else {
      doSomethingToGetAJavascriptError();
   }
}
....
try {
   doSomethingErrorProne();
}
catch (e) {
   alert(e.name);// alerts 'Error'
   alert(e.message); // alerts 'The message' or a JavaScript error message)
}

Quelltext der Version

<p>JavaScript unterstützt einen kompakten Satz von Anweisungen, die eingesetzt werden, 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 mit Anweisungsblöcken gruppiert. Ein Anweisungsblock wird mit 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 "2", weil sich die Anweisung "var x" innerhalb des Blocks im selben Sichtbarkeitsbereich befindet, wie die andere "var x"- Anweisung, die vor dem Block steht. Bei C oder Java wäre die Ausgabe "1".</p>
<h2 id="Bedingte_Anweisungen">Bedingte Anweisungen</h2>
<p>Eine bedingte Anweisung ist ein Satz von Befehlen, die ausgeführt werden, 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. Ferner 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><code>Bedingung</code> kann jeder Ausdruck sein, der zu true oder false evaluiert. Wenn die <code>Bedingung</code> zu true evaluiert, 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 anzugeben, 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>Außerdem 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 angeben möchte, ist es gängige Praxis diese in zusätzliche Klammern einzuschließen. 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>the empty string (<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. 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> <code>true</code>, wenn die Anzahl der Zeichen eines <code>Text</code>-Objekts "3" ist. Andernfalls wird eine Alarm-Nachricht gezeigt und false 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>Eine <code>switch</code> Anweisung erlaubt einem Skript einen Ausdruck auszuwerten und das Ergebnis mit den Ausdrücken der case-Labels zu vergleichen (Fallunterscheidung). Stimmt das Ergebnis überein, werden die entsprechenden Anweisungen 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>-Blocks 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 switch-Anweisung fortgesetzt. Der Konvention nach sollte der default-Abschnitt an letzter Stelle stehen, jedoch ist dieser Abschnitt 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 switch-Anweisung fortgesetzt. Wenn break nicht angegeben ist, findet auch kein Abbruch statt und somit werden die Anweisungen folgender case-Abschnitte ebenfalls ausgeführt, falls der Label-Wert mit dem Ausdruck ü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 switch 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 für die Manipulation von Objekten eingesetzt 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 Befehle aus, bis eine festgelegte Bedingung zu false evaluiert. Der JavaScript-Code der for-Schleife ist ähnlich wie bei Java und C. Eine for-Schleife sieht wie folgt aus:</p>
<pre class="brush: js">
for ([InitialAusdruck]; [Bedingung]; [InkrementAusdruck])
   Anweisung
</pre>
<p>Wenn eine <code>for</code>-Schleife ausgeführt wird, passiert folgendes:</p>
<ol>
  <li>Der Initialisierungs-Ausdruck <code>InitialAusdruck</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 true ist, wird die <code>Anweisung</code> ausgeführt. Wenn die Bedingung false ist, wird die Schleife abgebrochen. Fehlt der Ausdruck <code>Bedingung</code> komplett, wird angenommen, dass die <code>Bedingung</code> true 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>InkrementAusdruck</code> (üblicherweise wird hier 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 folgende Funktion 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. Sie stellt sicher, dass i kleiner ist als die Anzahl der verfügbaren Optionen des Select-Objekts (welche die Auszahl mehrerer Optionen erlaubt), führt den Anweisungsblock mit der if-Anweisung aus und erhöht die Variable i nach jedem Schleifendurchlauf um eins.</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>Die do...while Anweisung wiederholt die Ausführung solange bis eine bestimmte Bedingung zu false evaluiert. Eine do...while-Anweisung sieht wie folgt aus:</p>
<pre class="brush: js">
do
   statement
while (condition);
</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 die Bedingung true ist, wird die Anweisung erneut ausgeführt. Die Bedingung wird nach jedem Durchlauf überprüft. Wenn die Bedingung nicht mehr erfüllt ist, wird die Schleife abgebrochen und die Ausführung dahinter fortgesetzt.</p>
<p><strong>Beispiel</strong></p>
<p>Beim folgenden Beispiel wird mindestens ein Schleifendurchlauf ausgeführt und dies sooft wiederholt 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 while-Anweisung führt Anweisungen solange aus bis 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 hier müssen mehrere Anweisungen durch einen Anweisungsblock <code>({ ... })</code> gruppiert werden.</p>
<p><strong>Beispiel 1</strong></p>
<p>Die folgende while-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 n inkrementiert und der Wert zu x hinzuaddiert. Daher nehmen x und n 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 n &lt; 3 nicht mehr erfüllt, also wird die Schleife abgebrochen.</p>
<p><strong>Beispiel 2</strong></p>
<p>Man sollte darauf achten, dass man keine Endlos-Schleifen programmiert, 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:</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 ein Bezeichner verwendet werden, um eine Schleife zu markieren, und anschließend mit Hilfe von break oder continue veranlasst werden, dass die Schleife unterbrochen oder beim nächsten Durchlauf fortgesetzt wird.</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. Anweisung kann für beliebige Anweisungen stehen.</p>
<p><strong>Beispiel</strong><br />
  Bei diesem Beispiel markiert das Label markLoop eine while-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 spezifizierte 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 derWert 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 continue-Anweisung wird ein Sprung zum nächsten Schleifendurchlauf veranlasst.</p>
<ul>
  <li>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 es einen Sprung zum Inkrementierungs-Ausdruck.</li>
  <li>Steht nach continue ein Label, bewirkt es einen Sprung zu diesem Label.</li>
</ul>
<p><br />
  Die Syntax der continue-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 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 eins, drei, sieben und zwölf 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 checkiandj enthält eine weitere Anweisung mit dem Label checkj. Wenn continue erreicht ist, bricht das Skript die aktuelle Iteration 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 false liefert. Wenn false zurückgegeben wird, wird der Rest der Anweisung checkiandj bis zum Ende ausgeführt und checkiandj wiederholt, bis die zugehörige Bedingung false liefert. Wenn false zurückgegeben wird, wird die Ausführung bei der Anweisung hinter checkiandj fortgesetzt.</p>
<p>Wenn continue ein Label checkiandj hätte, würde das Skript am Anfang der checkiandj-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. Für jede vorhandene Eigenschaft eines Objekts werden die Anweisungen 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. Es wird dann über alle Objekteigenschaften iteriert und ein String mit den Namen der Eigenschaften und den Werten 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 auto mit den Eigenschaften <code>hersteller </code>und <code>modell</code> wäre das Ergebnis:</p>
<pre class="brush: js">
auto.hersteller = Ford
auto.modell = Mustang
</pre>
<p><strong>Arrays</strong></p>
<p>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 benutzerdefinierte 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); // prints "26", which is 5+13+8</pre>
<h2 id="Kommentare">Kommentare</h2>
<p>Kommentare sind Bemerkungen des Programm-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 Angabe 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">Anweisung zur Ausnahmebehandlung</h2>
<p>Mit der Anweisung <code>throw</code> können Ausnahmen eingeleitet und Werte von Ausdrücken <em>ausgeworfen</em> werden. Außerdem lässt sich mit Hilfe der try...catch-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="Exception_Types">Typen von Ausnahmen</h3>
<p>Nahezu jedes Objekt kann in JavaScript ausgeworfen werden, jedoch werden nicht alle Objekte auf dieselbe Weise erstellt. Während es Gang und Gäbe ist Numbers oder Strings als Error auszuwerfen, 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_Statement">throw-Anweisung</h3>
<p><code>Die throw</code>-Anweisung wird eingesetzt, um eine Ausnahmebehandlung einzuleiten und einen Ausdruck auszuwerfen. Beim Auswerfen eines Ausnahme-Ausdrucks, gibt man den Ausdruck mit dem Wert an, der ausgeworfen werden soll:</p>
<pre class="brush: js">
throw Ausdruck;
</pre>
<p>Es kann jede Art von Ausdruck benutzt werden, nicht nur Ausdrücke eines speziellen Typs. 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 Objekte angeben. Anschließend kann im catch-Block auf die Eigenschaften des 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_Statement">try...catch-Anweisung</h3>
<p><span style="color:#ff0000;">#######</span></p>
<p>&nbsp;</p>
<p>The <code>try...catch</code> statement marks a block of statements to try, and specifies one or more responses should an exception be thrown. If an exception is thrown, the <code>try...catch</code> statement catches it.</p>
<p>The <code>try...catch</code> statement consists of a <code>try</code> block, which contains one or more statements, and zero or more <code>catch</code> blocks, containing statements that specify what to do if an exception is thrown in the <code>try</code> block. That is, you want the <code>try</code> block to succeed, and if it does not succeed, you want control to pass to the <code>catch</code> block. If any statement within the <code>try</code> block (or in a function called from within the <code>try</code> block) throws an exception, control immediately shifts to the <code>catch</code> block. If no exception is thrown in the <code>try</code> block, the <code>catch</code> block is skipped. The <code>finally</code> block executes after the <code>try</code> and <code>catch</code> blocks execute but before the statements following the <code>try...catch</code> statement.</p>
<p>The following example uses a <code>try...catch</code> statement. The example calls a function that retrieves a month name from an array based on the value passed to the function. If the value does not correspond to a month number (1-12), an exception is thrown with the value <code>"InvalidMonthNo"</code> and the statements in the <code>catch</code> block set the <code>monthName</code> variable to <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">The catch Block</h4>
<p>You can use a <code>catch</code> block to handle all exceptions that may be generated in the <code>try</code> block.</p>
<pre class="brush: js">
catch (catchID) {
  statements
}
</pre>
<p>The <code>catch</code> block specifies an identifier (<code>catchID</code> in the preceding syntax) that holds the value specified by the <code>throw</code> statement; you can use this identifier to get information about the exception that was thrown. JavaScript creates this identifier when the <code>catch</code> block is entered; the identifier lasts only for the duration of the <code>catch</code> block; after the <code>catch</code> block finishes executing, the identifier is no longer available.</p>
<p>For example, the following code throws an exception. When the exception occurs, control transfers to the <code>catch</code> block.</p>
<pre class="brush: js">
try {
   throw "myException" // generates an exception
}
catch (e) {
// statements to handle any exceptions
   logMyErrors(e) // pass exception object to error handler
}
</pre>
<h4 id="The_finally_Block">The finally Block</h4>
<p>The <code>finally</code> block contains statements to execute after the <code>try</code> and <code>catch</code> blocks execute but before the statements following the <code>try...catch</code> statement. The <code>finally</code> block executes whether or not an exception is thrown. If an exception is thrown, the statements in the <code>finally</code> block execute even if no <code>catch</code> block handles the exception.</p>
<p>You can use the <code>finally</code> block to make your script fail gracefully when an exception occurs; for example, you may need to release a resource that your script has tied up. The following example opens a file and then executes statements that use the file (server-side JavaScript allows you to access files). If an exception is thrown while the file is open, the <code>finally</code> block closes the file before the script fails.</p>
<pre class="brush: js">
openMyFile();
try {
    writeMyFile(theData); //This may throw a error
}catch(e){
    handleError(e); // If we got a error we handle it
}finally {
    closeMyFile(); // always close the resource
}
</pre>
<p>If the <code>finally</code> block returns a value, this value becomes the return value of the entire <code>try-catch-finally</code> production, regardless of any <code>return</code> statements in the <code>try</code> and <code>catch</code> blocks:</p>
<pre class="brush: js">
function f() {
    try {
        alert(0);
        throw "bogus";
    } catch(e) {
        alert(1);
        return true; // this return statement is suspended until finally block has completed
        alert(2); // not reachable
    } finally {
        alert(3);
        return false; // overwrites the previous "return"
        alert(4); // not reachable
    }
    // "return false" is executed now
    
    alert(5); // not reachable
}
f(); // alerts 0, 1, 3; returns false
</pre>
<h4 id="Nesting_try...catch_Statements" name="Nesting_try...catch_Statements">Nesting try...catch Statements</h4>
<p>You can nest one or more <code>try...catch</code> statements. If an inner <code>try...catch</code> statement does not have a <code>catch</code> block, the enclosing <code>try...catch</code> statement's <code>catch</code> block is checked for a match.</p>
<h3 id="Utilizing_Error_objects">Utilizing Error objects</h3>
<p>Depending on the type of error, you may be able to use the 'name' and 'message' properties to get a more refined message. 'name' provides the general class of Error (e.g., 'DOMException' or 'Error'), while 'message' generally provides a more succinct message than one would get by converting the error object to a string.</p>
<p>If you are throwing your own exceptions, in order to take advantage of these properties (such as if your catch block doesn't discriminate between your own exceptions and system ones), you can use the Error constructor. For example:</p>
<pre class="brush: js">
function doSomethingErrorProne () {
   if (ourCodeMakesAMistake()) {
      throw (new Error('The message'));
   }
   else {
      doSomethingToGetAJavascriptError();
   }
}
....
try {
   doSomethingErrorProne();
}
catch (e) {
   alert(e.name);// alerts 'Error'
   alert(e.message); // alerts 'The message' or a JavaScript error message)
}</pre>
Zu dieser Version zurücksetzen