4.3 Kontrollstrukturen: Schleifen 

Hin und wieder kommt es vor, dass eine Anweisung mehrmals ausgeführt werden muss, beispielsweise bei einer Aufzählung. Hierzu bietet JavaScript mehrere Kontrollstrukturen an. Mit JavaScript Version 1.2 (sowie beim Internet Explorer 4) wurden neue Kontrollstrukturen eingeführt, die aber mit dem Befehlssatz von JavaScript 1.0 vollständig nachgebildet werden können.

4.3.1 For-Schleifen 

Diese Art der Schleife führt eine Anweisung eine (in der Regel) bestimmte Anzahl von Malen aus. Die Syntax sieht dabei folgendermaßen aus:

for (Initialisierung; Bedingung; Befehlsfolge) {
   //Anweisungen
}

Die for-Schleife hat drei Parameter:

Initialisierung: Oft läuft bei einer Schleife eine Zählvariable mit, die die Anzahl der Wiederholungen zählt. Diese Variable kann hier initialisiert werden. Sollen mehrere Variablen initialisiert werden, so werden die einzelnen Anweisungen durch Kommata voneinander getrennt.

Bedingung: Die for-Schleife wird so lange ausgeführt, bis diese Bedingung nicht mehr erfüllt ist.

Befehlsfolge: Nach jedem Durchlauf der Anweisungen wird diese Befehlsfolge (in der Regel ein Befehl; mehrere Befehle werden durch Kommata voneinander getrennt) ausgeführt. Wenn die Schleife irgendwann enden soll, sollten hier in der Regel Befehle ausgeführt werden, die nach einer bestimmten Anzahl von Durchläufen die Bedingung (den zweiten Parameter) nicht mehr erfüllbar machen.

Die geschweiften Klammern um den Anweisungsblock sind dann zwingend, wenn der Block aus mehr als einem Befehl besteht. Handelt es sich um nur einen Befehl, so kann man die geschweiften Klammern weglassen. Man sollte aber zumindest den Code einrücken, damit das Ganze übersichtlich und lesbar bleibt. Generell ist es aber empfehlenswert, immer geschweifte Klammern zu verwenden.

Der folgende Code gibt zehnmal Galileo aus. Dabei wird eine Zählvariable mit 0 initialisiert und in jedem Schleifendurchlauf um eins erhöht. Die Abbruchbedingung prüft, ob die Zählvariable kleiner als zehn ist. Vor dem elften Durchlauf wird die Variable auf zehn erhöht, und die Schleife wird verlassen.

for (var i=0; i<10; i++) {
   document.write("Galileo<br />");
}

Sehr oft wird die Zählvariable auch direkt in der Schleife verwendet. Der folgende Code gibt alle Quadratzahlen von 0 = 0 bis 10 = 100 aus:

for (var i=0; i<=10; i++) {
   document.write("Das Quadrat von " + i + " ist: ");
   document.write(i*i + "<br />");
}

Sie sehen hierbei die Verwendung des Plus-Operators: Hier werden eine Zeichenkette und eine Zahl zusammengefügt. Das Ergebnis ist eine Zeichenkette, die Zahl wird also in eine Zeichenkette umgewandelt.

Beachten Sie ebenso, dass Sie einen Zeilenumbruch nicht mit \r\n angeben sollten, sondern mit dem entsprechenden HTML-Tag, <br/>.

Wie bereits erwähnt wurde, kann man auch mehrere Zählvariablen verwenden, die man dann durch Kommata voneinander trennen muss. Anwendungen dafür gibt es ziemlich selten: Hier folgt ein sehr praxisfremdes Beispiel. Es werden zwei Zählvariablen verwendet, i und j. Die erste enthält eine Zahl, die zweite eine Zeichenkette. Der Zahlenwert wird in eine Zeichenkette umgewandelt und an j angehängt. Sobald j mehr als 15 Zeichen enthält, wird die Schleife verlassen.

for (var i=0, j=""; j.length<=15; i++, j += i) {
   document.write(i + " – " + j + "<br />");
}

Dieses Programm gibt Folgendes auf dem Bildschirm aus:

0 –
1 – 1
2 – 12
3 – 123
4 – 1234
5 – 12345
6 – 123456
7 – 1234567
8 – 12345678
9 – 123456789
10 – 12345678910
11 – 1234567891011
12 – 123456789101112

Vor dem nächsten Schleifendurchlauf würde an die Zeichenkette 13 angehängt, die Länge würde dadurch auf 17 Zeichen anwachsen, also wird die Schleife hier verlassen.

4.3.2 Do-while-Schleife 

Nicht immer weiß man, wie oft ein Anweisungsblock hintereinander ausgeführt werden soll. Stattdessen will man den Block so lange ausführen, bis eine Bedingung nicht mehr erfüllt ist. Im folgenden Beispiel sollen in einer Zeichenkette alle As durch Bs ersetzt werden. Hierbei ist die Methode Zeichenkette.indexOf(Teilstring) nützlich; diese gibt nämlich zurück, an welcher Position in der Zeichenkette der Teilstring das erste Mal vorkommt. Ist der Teilstring nicht in der Zeichenkette enthalten, wird –1 zurückgegeben. Das erste Zeichen steht, wie auch schon vorher, an Position 0.

Die Syntax sieht wie folgt aus:

do {
   //Anweisungsblock
} while (Bedingung);

Der Anweisungsblock wird ausgeführt, und dann wird die Bedingung überprüft. Ist sie erfüllt, wird der Block erneut ausgeführt (und dann wird wieder die Bedingung geprüft); andernfalls wird die Schleife verlassen.

var Zk = "AXAYAZ";  //Zk steht für "Zeichenkette"
do {
   io = Zk.indexOf("A");
   Zk = Zk.substring(0, io) + "B" +
        Zk.substring(io+1, Zk.length);
} while (Zk.indexOf("A")>-1);

Nach dem Durchlauf enthält Zk den Wert BXBYBZ.

Beachten Sie insbesondere, dass die Schleife auf jeden Fall einmal ausgeführt wird! Im Beispiel führt das zu einem Fehler, wenn die Zeichenkette zu Anfang überhaupt kein A enthält. Im Folgenden lernen Sie Methoden kennen, um diesen Fehler zu vermeiden.

Noch ein Wort zu der Zuweisung: Wenn Sie bei einer Zeichenkette z das Zeichen an der Stelle x in das Zeichen X ändern wollen (die Zählung beginnt wie immer bei 0), kommen Sie mit folgender Anweisung weiter:

z = z.substring(0, x) + "X" + z.substring(x+1, z.length);

Alle Zeichen vor und hinter dem zu ändernden Zeichen bleiben durch die beiden substring()-Anweisungen erhalten.

4.3.3 While-Schleife 

Schon seit JavaScript Version 1.0 gibt es eine weitere Form der Schleifen, und zwar while-Schleifen (ohne do). Die Syntax ist der von do-while-Schleifen sehr ähnlich, der Unterschied steckt im Detail:

while (Bedingung) {
   //Anweisungsblock
}

Die Bedingung wird hier vor dem Durchlaufen des Anweisungsblocks überprüft. Im Beispiel von oben, bei der Ersetzung aller As durch Bs, ist das sehr nützlich, da hier der Anweisungsblock nicht ausgeführt wird, wenn die Zeichenkette von Anfang an keine As enthält:

var Zk = "AXAYAZ"  //Zk steht für "Zeichenkette"
while (Zk.indexOf("A")>-1) {
   io = Zk.indexOf("A")
   Zk = Zk.substring(0, io) + "B" + Zk.substring(io+1, Zk.length)
}

4.3.4 For-in-Schleife 

Diese Schleife wird recht selten verwendet, und an dieser Stelle fehlt Ihnen noch das Grundwissen über Objekte, um Ihnen eine ausreichende Erklärung geben zu können. Prinzipiell sei gesagt, dass man mit der Schleife durch alle Eigenschaften eines Objekts und alle Elemente einer Variablensammlung (eines Arrays, dazu später mehr) laufen kann. Die folgende Schleife gibt das name-Attribut aller Elemente eines Formulars wieder. Spätestens in Kapitel 9 werden Sie diesen Code verstehen; vorerst aber müssen Sie mir leider blind vertrauen. Die for-in-Schleifen werden ohnehin sehr selten eingesetzt.

for (e in document.forms[0].elements) {
   document.write(e.name + "<br />")
}

4.3.5 Schleifensteuerung 

Eine Schleife muss nicht unbedingt so oft durchlaufen werden, wie vorgesehen ist. Angenommen, in einer Schleife wird eine Zeichenkette auf das Vorhandensein eines bestimmten Zeichens überprüft (das geht mit indexOf() sehr schnell, aber darauf gehen wir an dieser Stelle nicht ein). Sobald das Zeichen gefunden worden ist, muss die Schleife nicht unbedingt weiter ausgeführt werden, denn das Ergebnis (»Das Zeichen ist in der Zeichenkette enthalten«) steht ja jetzt schon fest. Aus diesem Grund gibt es den Befehl break, der das sofortige Verlassen der aktuellen Schleife veranlasst. Der Interpreter fährt also hinter dem aktuellen Anweisungsblock fort.

Ebenso kann es bei Schleifen, insbesondere bei for-Schleifen, immer wieder vorkommen, dass man zum nächsten Schleifendurchlauf springen möchte (beispielsweise, wenn man genau weiß, dass dieser Durchlauf nicht das gewünschte Ergebnis bringt) und den Rest der Schleife aus Effizienzgründen nicht ausführen lassen will. Der entsprechende Befehl heißt continue.

Wieder ist es leider so, dass Ihr momentanes Wissen noch nicht ausreicht, um hier ein sinnvolles Beispiel anzugeben. Am Ende des Kapitels werden Sie aber in der Lage sein, die Befehle break und continue einzusetzen.