mitmario.dev

Schleifen ineinander

JavaScript Im Browser 3 Min Lesezeit 4 BeispieleLektion 4 von 6

Drei Zeilen und vier Spalten ergeben zwölf Felder. Eine einzelne Schleife geht aber nur eine Reihe entlang. Für alles mit einem Raster, eine Tabelle oder einen Kalender, steht deshalb eine Schleife in der anderen. Die eine geht die Zeilen durch, die andere die Spalten.

Wie oft die innere Schleife läuft

Die innere läuft für jeden Durchlauf der äußeren
let durchlaeufe = 0;

for (let aussen = 1; aussen <= 3; aussen++) {
  console.log("Äußere Runde", aussen, "beginnt");

  for (let innen = 1; innen <= 4; innen++) {
    durchlaeufe++;
  }

  console.log("  Die innere ist viermal gelaufen");
}

console.log("Insgesamt:", durchlaeufe, "Durchläufe");

Die innere Schleife läuft vollständig für jeden einzelnen Durchlauf der äußeren. Sie beginnt jedes Mal von vorn. Bei einer äußeren mit 3 Runden und einer inneren mit 4 sind das 12 Durchläufe. Die Zahlen multiplizieren sich.

Im Reiter Debug kannst du das durchblättern. Solange aussen=1 dasteht, zählt innen von 1 bis 4 durch. Erst danach springt aussen auf 2.

Deshalb werden verschachtelte Schleifen schnell teuer. Bei 10 mal 10 sind es 100 Durchläufe, bei 1000 mal 1000 eine Million. Hängt eine Seite plötzlich, frage ich zuerst, ob dort zwei Schleifen ineinanderliegen und wie groß die Zahlen darin sind.

Für das Dreieck in der Aufgabe und die Tabelle in der nächsten Lektion spielt das keine Rolle. Ab drei Ebenen und größeren Zahlen schon, und dann schneidet man das Problem anders. Wie, ist ein eigenes Fachgebiet und nicht Teil dieses Kurses.

Das Muster für ein Raster

Ein Raster bauen
// Außen die Zeile, innen die Spalte. Das ist die übliche Aufteilung.
for (let zeile = 1; zeile <= 3; zeile++) {
  let text = "";

  for (let spalte = 1; spalte <= 4; spalte++) {
    text += zeile * spalte + " ";
  }

  // Erst nach der inneren Schleife wird die Zeile ausgegeben.
  console.log(text);
}

Üblich ist außen die Zeile und innen die Spalte. Eine Zeile ist erst fertig, wenn alle ihre Spalten abgearbeitet sind, also wird sie in der inneren Schleife zusammengesammelt und erst dann ausgegeben, wenn die innere Schleife durch ist.

let text = "" steht dabei innerhalb der äußeren Schleife und außerhalb der inneren. So bekommt jede Zeile ihren eigenen leeren Text. Steht er ganz oben, wächst er über alle Zeilen hinweg zu einem einzigen langen Wurm zusammen.

Das ist die Regel vom Aufsummieren, eine Ebene tiefer. Der Sammelbehälter steht genau eine Stufe über der Schleife, die ihn füllt.

Zwei Zähler, zwei Namen

Zwei Zähler brauchen zwei Namen
// Beide Schleifen benutzen i. Das läuft sogar, weil die innere ihr
// eigenes i bekommt. Beim Lesen weiß trotzdem niemand mehr, welches
// i gerade gemeint ist.
for (let i = 1; i <= 2; i++) {
  let text = "";
  for (let i = 1; i <= 3; i++) {
    text += i;
  }
  console.log("Innen ergab", text, "und außen steht i auf", i);
}

console.log("---");

// Mit sprechenden Namen ist die Frage gar nicht erst da.
for (let zeile = 1; zeile <= 2; zeile++) {
  let text = "";
  for (let spalte = 1; spalte <= 3; spalte++) {
    text += spalte;
  }
  console.log("Zeile", zeile, "ergab", text);
}

Im ersten Block heißen beide Zähler i. Das ist erlaubt und läuft sogar richtig, denn die innere Schleife bekommt ihr eigenes i und verdeckt damit so lange das äußere. Lesbar ist es nicht. Bei text += i musst du erst herausfinden, welches der beiden gemeint ist. Und wird die innere Schleife später entfernt, ändert dieselbe Zeile still ihre Bedeutung.

In der Aufzeichnung im Reiter Debug siehst du die Verdeckung. In der inneren Schleife zählt i bis 3, und in der Zeile mit console.log direkt danach steht wieder i=1. Zurückgesetzt wurde nichts. Dort steht einfach ein anderer Name mit demselben Wortlaut.

Sobald zwei Schleifen ineinanderliegen, nehme ich sprechende Namen, zeile und spalte oder was sonst zum Problem passt. Das Kürzel i ist eine Redewendung für eine einzelne kurze Schleife. Für ein Raster ist es nicht gedacht.

break und continue in verschachtelten Schleifen

break wirkt nur auf die innerste
for (let zeile = 1; zeile <= 3; zeile++) {
  for (let spalte = 1; spalte <= 5; spalte++) {
    if (spalte === 3) {
      break;
    }
    console.log("Zeile", zeile, "Spalte", spalte);
  }
}

console.log("Die äußere Schleife lief trotzdem dreimal komplett durch.");

Beide wirken auf die innerste Schleife, in der sie stehen. Ein break in der inneren beendet also nur die innere. Die äußere macht mit ihrem nächsten Durchlauf weiter, und die innere fängt wieder von vorn an. Im Beispiel bricht die innere Schleife jedes Mal bei Spalte 3 ab, und trotzdem gibt es drei Zeilen.

Sollen wirklich beide enden, brauchst du eine zusätzliche Bedingung in der äußeren Schleife oder, deutlich besser, eine eigene Funktion mit return. In JavaScript gibt es zwar auch benannte Sprungmarken, mit denen ein break mehrere Ebenen auf einmal verlässt. Die stehen aber selten in Code, und wo sie stehen, wäre eine Funktion fast immer die bessere Antwort.

In der Aufgabe baust du aus zwei Schleifen ein Dreieck aus Sternen, als einen einzigen Text.

Zum Mitnehmen

Bei zwei Schleifen ineinander multiplizieren sich die Durchläufe. Außen läuft die Zeile, innen die Spalte, und der Text für eine Zeile wird zwischen beiden angelegt.

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.