mitmario.dev

Die for-Schleife

JavaScript Im Browser 5 Min Lesezeit 4 BeispieleLektion 1 von 6

Fünf Zahlen ausgeben geht noch mit fünf Zeilen console.log. Bei fünfzig schreibt das niemand mehr hin. Und wenn die Anzahl erst beim Laufen feststeht, geht es gar nicht. Eine Schleife wiederholt einen Block, bis eine Bedingung nicht mehr zutrifft.

Die drei Teile

Die drei Teile
// Startwert: i = 1. Bedingung: solange i <= 5. Schritt: i um eins hoch.
for (let i = 1; i <= 5; i++) {
  console.log("Durchlauf", i);
}

console.log("---");

// Rückwärts geht genauso, man dreht Startwert, Bedingung und Schritt um.
for (let i = 3; i >= 1; i--) {
  console.log("Countdown", i);
}

console.log("---");

// Und in Zweierschritten.
for (let i = 0; i <= 10; i += 2) {
  console.log("Gerade Zahl", i);
}

In den runden Klammern stehen drei Angaben. Getrennt werden sie durch Semikolons, nicht durch Kommas.

Der Startwert legt den Zähler an und gibt ihm seinen ersten Wert, hier let i = 1. Die Bedingung i <= 5 wird vor jedem Durchlauf geprüft. Ist sie wahr, läuft der Block. Ist sie falsch, ist die Schleife zu Ende. Und der Schritt i++ läuft nach jedem Durchlauf und verändert den Zähler.

So laufen die Teile auch ab. Erst der Startwert, dann wird geprüft, dann kommt der Block, dann der Schritt, und dann wird wieder geprüft. Der Schritt kommt nach dem Block, deshalb hat der erste Durchlauf noch den Startwert. Rückwärts geht es mit umgedrehtem Startwert, umgedrehter Bedingung und i--. Mit i += 2 zählst du in Zweierschritten.

Der Zähler heißt traditionell i, für Index, das englische Wort für die Position. Das ist so verbreitet, dass es jeder sofort liest. Bei zwei ineinanderliegenden Schleifen nimmt man i und j, und ab da wird es unübersichtlich. Sobald die Schleife länger als drei Zeilen ist, nehme ich einen sprechenden Namen wie zeile oder position.

Der Zähler gehört übrigens der Schleife. Nach ihrem Ende gibt es ihn nicht mehr, und warum das so ist, klärt Abschnitt 5.

Warum von null gezählt wird

Warum von null gezählt wird
const wort = "Kurs";

// Positionen beginnen bei 0. Deshalb zählt die Schleife von 0
// und läuft, solange i kleiner als die Länge ist.
for (let i = 0; i < wort.length; i++) {
  console.log(i, wort[i]);
}

console.log("Länge:", wort.length);
console.log("Letzte Position:", wort.length - 1);

Das erste Beispiel fängt bei 1 an, weil es Zahlen ausgibt. Bei Positionen fängt man bei 0 an. Das erste Zeichen eines Textes steht an Position 0, der erste Eintrag einer Liste auch. Ein Text mit vier Zeichen hat also die Positionen 0, 1, 2 und 3. Mit wort[i] holst du das Zeichen an Position i.

Wenn du über alle Positionen eines Textes laufen willst, brauchst du deshalb den Startwert i = 0, die Bedingung i < wort.length und den Schritt i++. Mit <= liefe die Schleife einen Durchlauf zu weit. Sie griffe dann auf eine Position zu, die es nicht gibt. Von 0 gezählt heißt <, von 1 gezählt heißt <=.

Etwas aufsummieren

Etwas aufsummieren
// Der Sammelbehälter steht AUSSERHALB der Schleife.
let summe = 0;

for (let i = 1; i <= 5; i++) {
  summe += i;
  console.log("Nach Durchlauf", i, "steht summe auf", summe);
}

console.log("Am Ende:", summe);

Der Sammelbehälter steht außerhalb der Schleife. Schreibst du let summe = 0 in den Block, fängt die Summe bei jedem Durchlauf wieder bei null an. Nach der Schleife gibt es den Namen dann gar nicht mehr, und die Console meldet summe is not defined.

Dasselbe gilt für alles, was sich über die Durchläufe hinweg aufbaut. Ein Zähler, ein Text, der zusammenwächst, eine Liste, die sich füllt. Angelegt wird vor der Schleife, verändert in der Schleife und benutzt nach der Schleife.

Der Reiter Debug

Bei einer Schleife steht in der Ausgabe zum ersten Mal nicht mehr die ganze Geschichte. Da stehen fünf Zeilen, und was zwischen ihnen passiert ist, musst du dir denken.

Dafür gibt es einen vierten Reiter, Debug. Ein Druck auf Aufzeichnen lässt deinen Code noch einmal laufen, und diesmal meldet er vor jeder Zeile, welche Werte gerade in den Variablen stehen. Danach steht dort eine Liste. Mit den Pfeilen blätterst du hindurch, und der Editor springt jeweils in die Zeile mit.

Beim Beispiel zum Aufsummieren kommen dreizehn Schritte zusammen, und sie lesen sich wie ein Zickzack. Erst i=1, dann summe=1, dann i=2, dann summe=3, dann i=3, dann summe=6. An jeder Zeile steht, was sich dort geändert hat, und am angeklickten Schritt stehen alle Werte untereinander. So siehst du, was im dritten Durchlauf passiert ist, ohne eine Zeile console.log einzubauen und hinterher wieder herauszunehmen.

Aufgezeichnet wird die Datei, an der du gerade arbeitest. Hat der Code einen Syntaxfehler, tut Aufzeichnen nichts, und die Meldung steht in der Console. Bei einer sehr langen Schleife hört die Aufzeichnung nach zweitausend Schritten auf, mit einem Hinweis dazu. Zum Verstehen reichen die ersten zweitausend allemal. Ab hier ist der Reiter für den Rest des Kurses da, und in Abschnitt 14 kommt er beim Fehlersuchen wieder.

Die Endlosschleife

Fast eine Endlosschleife
let i = 0;

// Der Zähler i wird hier absichtlich nie erhöht, die Bedingung
// i < 3 bleibt also für immer wahr. Nur die Notbremse
// (versuche) bricht das Ganze ab. Ohne sie wäre der Browser weg.
for (let versuche = 0; i < 3 && versuche < 5; versuche++) {
  console.log("Durchlauf", versuche, "und i steht immer noch auf", i);
}

console.log("Abgebrochen, weil die Notbremse griff.");

Wird die Bedingung nie falsch, arbeitet der Browser die Schleife ab, so schnell er kann. Etwas anderes tut er in der Zwischenzeit nicht. Die Seite reagiert nicht mehr auf Klicks, nichts wird neu gezeichnet, und nach einigen Sekunden bietet der Browser an, die Seite anzuhalten.

Meistens fehlt der Schritt, oder er verändert den falschen Wert. Im Beispiel wird i nie erhöht, also bleibt i < 3 für immer wahr. Beendet wird das Ganze nur von der Notbremse, einem zweiten Zähler mit fester Obergrenze. Genauso gut kann der Schritt in die falsche Richtung laufen, etwa i-- bei der Bedingung i < 10.

Die Aufzeichnung dieses Beispiels hat acht Schritte. Ab dem zweiten Schritt steht in jedem i=0, und daneben zählt versuche brav von 0 bis 4 hoch, ohne dass sich an i irgendetwas tut. Ein Wert, der sich nie ändert, obwohl die Bedingung ihn prüft, steht dort also Schritt für Schritt untereinander. Das geht allerdings nur, weil die Notbremse da ist. Bei einer Schleife, die wirklich nie endet, hilft der Reiter nicht. Der Browser kommt dann gar nicht mehr dazu, irgendetwas anzuzeigen, und nachgemessen hängt die Seite auch nach einer Minute noch.

Eine Notbremse in Übungscode ist deshalb vernünftig, sobald die Abbruchbedingung nicht auf den ersten Blick zwingend ist. In der nächsten Lektion steht die Anzahl der Durchläufe gar nicht fest, und dort kommt sie wieder.

In der Lektionsansicht läuft geänderter Code schon beim Tippen. Läuft eine Schleife dabei länger als eine Sekunde, wird sie von selbst angehalten, und in der Console steht, in welcher Zeile sie beginnt. Bei „Prüfen“, „Seite neu laden“ und „Aufzeichnen“ ist das anders. Dort läuft der Code genau so, wie er dasteht, und eine Schleife ohne Ende lässt die Seite hängen wie in jedem anderen Browser. Nach dem Neuladen der Lektion steht der Code wieder im Editor und läuft wieder mit der Grenze.

In der Aufgabe zählt deine erste eigene Schleife ungerade Zahlen und summiert sie dabei.

Zum Mitnehmen

Startwert, Bedingung und Schritt stehen in der Reihenfolge da, in der sie ablaufen. Was sich über die Durchläufe aufbaut, wird vor der Schleife angelegt, und eine Bedingung, die nie falsch wird, hält die ganze Seite an.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

Was in dieser Lektion steckt

  • Artikel mit 4 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe im Editor, direkt im Browser geprüft

    Öffnet sich mit dem Basis Konto.