Abschnitt 4 · Lektion 5
Synthese: das Einmaleins
Eine Zahlentabelle in der Console, deren Spalten sauber untereinanderstehen, auch wenn die Zahlen verschieden lang sind. Dafür reichen zwei Schleifen ineinander, eine Bedingung darin und ein Text, der Stück für Stück wächst. Ob das Ergebnis stimmt, siehst du einer Tabelle sofort an.
Erst hinschreiben, dann erzeugen
<h1>Ausgabe</h1>
<p>Was dieses Beispiel tut, steht in der Console.</p> // So soll es aussehen. Von Hand hingeschrieben, bevor eine
// einzige Schleife existiert.
console.log("Zeile 1: 1 2 3");
console.log("Zeile 2: 2 4 6");
console.log("Zeile 3: 3 6 9");
console.log("---");
// Und jetzt dieselbe Ausgabe, erzeugt statt getippt.
for (let zeile = 1; zeile <= 3; zeile++) {
let text = "Zeile " + zeile + ":";
for (let spalte = 1; spalte <= 3; spalte++) {
text += String(zeile * spalte).padStart(5);
}
console.log(text);
} Ich schreibe zuerst von Hand hin, wie das Ergebnis aussehen soll. Drei Zeilen reichen. Damit gibt es ein Ziel, das man anschauen kann, statt einer Vorstellung im Kopf. Du siehst dann, wo Leerzeichen hingehören, wie breit die Spalten sein müssen und was am Zeilenanfang steht. Läuft die Schleife, legst du beides untereinander und vergleichst.
Ohne diesen Schritt entstehen Schleife und Formatierung gleichzeitig. Sieht das Ergebnis dann krumm aus, weiß niemand, welches von beidem schuld ist.
Sammeln statt einzeln ausgeben
<h1>Ausgabe</h1>
<p>Was dieses Beispiel tut, steht in der Console.</p> // So nicht: jede Zahl bekommt ihre eigene Zeile.
console.log("Einzeln ausgegeben:");
for (let zeile = 1; zeile <= 2; zeile++) {
for (let spalte = 1; spalte <= 3; spalte++) {
console.log(zeile * spalte);
}
}
console.log("---");
// So schon: die Zeile wird gesammelt und einmal ausgegeben.
console.log("Gesammelt:");
for (let zeile = 1; zeile <= 2; zeile++) {
let text = "";
for (let spalte = 1; spalte <= 3; spalte++) {
text += zeile * spalte + " ";
}
console.log(text);
} In der ersten Fassung wird jede Zahl einzeln ausgegeben. Heraus kommt eine lange Spalte, und von einer Tabelle ist nichts zu sehen. console.log schreibt nämlich immer eine ganze Zeile, und an die vorige Zeile lässt sich nichts anhängen.
Deshalb wird die Zeile in einem Text gesammelt und erst ausgegeben, wenn sie fertig ist. Der Text wird vor der inneren Schleife angelegt und nach ihr ausgegeben. Das ist das Muster aus der vorigen Lektion, und hier zeigt sich, wozu es gut ist.
Auf einer echten Seite ist es später dasselbe, denn dort entsteht erst der ganze Abschnitt Markup, und dann kommt er in einem Stück auf die Seite statt zehnmal einzeln. Das ist Abschnitt 11.
Ausrichten mit padStart
<h1>Ausgabe</h1>
<p>Was dieses Beispiel tut, steht in der Console.</p> // Ohne Ausrichtung rutschen die Spalten, sobald eine Zahl länger wird.
console.log("Ohne padStart:");
for (let zeile = 8; zeile <= 10; zeile++) {
let text = "";
for (let spalte = 8; spalte <= 10; spalte++) {
text += zeile * spalte + " ";
}
console.log(text);
}
console.log("---");
// padStart füllt links mit Leerzeichen auf, bis die Breite stimmt.
console.log("Mit padStart:");
for (let zeile = 8; zeile <= 10; zeile++) {
let text = "";
for (let spalte = 8; spalte <= 10; spalte++) {
text += String(zeile * spalte).padStart(5);
}
console.log(text);
} Sobald die Zahlen verschieden lang sind, rutschen die Spalten. Im Beispiel stehen zwei- und dreistellige Zahlen nebeneinander, 64 neben 100.
padStart(breite) füllt einen Text links mit Leerzeichen auf, bis er die gewünschte Breite hat. Ist er schon länger, passiert nichts. Es ist eine Methode für Texte, deshalb steht String(...) darum. Direkt an einer Zahl gibt es einen TypeError, im Beispiel (zeile * spalte).padStart is not a function.
Links aufgefüllt stehen die Einerstellen untereinander, und so liest man Zahlen. Ohne CSS klappt das hier nur wegen der Schrift der Console, denn in ihr ist jedes Zeichen gleich breit. Auf einer Webseite mit gewöhnlicher Schrift richtet man mit CSS aus.
Eine Stelle auslassen
<h1>Ausgabe</h1>
<p>Was dieses Beispiel tut, steht in der Console.</p> // Wo das Ergebnis ungerade ist, kommen vier Leerzeichen statt
// der Zahl. Die Lücke behält ihre Breite, das Raster bleibt stehen.
for (let zeile = 1; zeile <= 4; zeile++) {
let text = "";
for (let spalte = 1; spalte <= 4; spalte++) {
if ((zeile * spalte) % 2 === 1) {
text += " ";
continue;
}
text += String(zeile * spalte).padStart(4);
}
console.log(text);
} Die letzte Zutat ist eine Bedingung mitten in der inneren Schleife. Ausgelassen wird hier jedes ungerade Ergebnis. Das sind genau die Stellen, an denen Zeile und Spalte beide ungerade sind.
Die Lücke behält dabei ihre Breite, und statt der Zahl stehen vier Leerzeichen da. Fiele die Stelle einfach weg, rutschte der Rest der Zeile nach links. Dann wäre das Raster hin. Ob es richtig gemacht wurde, erkennst du also beim Anschauen sofort.
Das continue ist hier Geschmackssache, ein else täte dasselbe. Es passt nur gut zu dem Muster, bei dem der Sonderfall oben steht und der Normalfall ohne zusätzliche Einrückung darunter.
In der Aufgabe entsteht das kleine Einmaleins als Tabelle, zehn Zeilen zu zehn Werten mit einer ausgelassenen Diagonale.
Zum Mitnehmen
Die Ausgabe steht zuerst von Hand da, dann wird sie erzeugt. Eine Zeile wird gesammelt und einmal ausgegeben, padStart richtet die Zahlen rechtsbündig aus, und eine Lücke behält ihre Breite.
Jetzt du
Basis Konto, kostenlosZu 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.