Abschnitt 14 · Lektion 4
Debuggen
Der Durchschnitt stimmt nicht, eine Fehlermeldung gibt es nicht, und die erste Idee ist, am Code herumzuändern, bis es wieder geht. Das fühlt sich schneller an. Ist es aber nie. Am Ende steht Code da, den niemand mehr versteht, weil an drei Stellen etwas geändert wurde, das mit dem Problem nichts zu tun hatte.
Beim anderen Weg findest du erst heraus, wo es schiefgeht, und änderst dann an genau dieser Stelle etwas.
Die Reihenfolge, die fast immer funktioniert
Vier Schritte, und meistens ist man nach dem zweiten fertig.
- Die Fehlermeldung lesen, ganz, mit Art, Text, Datei und Zeile. Das klingt selbstverständlich und wird trotzdem übersprungen, weil rote Schrift unangenehm ist.
- Die genannte Zeile ansehen, nicht die, an der man zuletzt gearbeitet hat, sondern die aus der Meldung.
- Die Werte prüfen, also was wirklich in den Variablen steht, die dort vorkommen, und nicht, was dort stehen sollte.
- Halbieren. Ist immer noch unklar, wo es klemmt, wird der Weg in der Mitte geteilt und nachgesehen, ob der Zwischenstand dort noch stimmt.
Gibt es keine Meldung und kommt einfach das Falsche heraus, geht es direkt bei Schritt 3 los.
console.log richtig benutzen
<p>Dreimal dieselbe Information, unterschiedlich brauchbar.</p> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
p {
margin: 0 0 0.75rem;
} const warenkorb = [
{ name: "Tastatur", preisInCent: 4900, menge: 2 },
{ name: "Maus", preisInCent: 1900, menge: 1 },
{ name: "Kabel", preisInCent: 700, menge: 3 },
];
// Drei Zahlen ohne Zusammenhang.
console.log(warenkorb.length);
console.log(warenkorb[0].preisInCent);
console.log(warenkorb[0].preisInCent * warenkorb[0].menge);
// Hier sagt jede Ausgabe, was sie zeigt.
console.log("Positionen:", warenkorb.length);
console.log("Preis der ersten Position:", warenkorb[0].preisInCent);
console.log("Zeilensumme der ersten Position:", warenkorb[0].preisInCent * warenkorb[0].menge);
// Für eine Liste von Objekten gibt es console.table.
console.table(warenkorb); Mit console.log siehst du dem Programm beim Denken zu. Es hat nur eine Schwäche, und die ist selbstgemacht. Wenn du fünf nackte Werte ausgibst, stehen in der Console fünf Zahlen, und keiner weiß mehr, welche wozu gehört.
Ich schreibe deshalb immer eine Beschriftung davor. Ein Aufruf nimmt beliebig viele Argumente und setzt sie mit Leerzeichen dazwischen hintereinander.
Für eine Liste von Objekten gibt es console.table. Damit bekommst du eine echte Tabelle mit einer Spalte je Eigenschaft, und bei Daten aus dem Netz ist das viel wert.
Für Schleifen gibt es console.group und console.groupEnd. Alles dazwischen wird eingerückt und lässt sich zuklappen.
<p>console.group fasst zusammen, was zusammengehört.</p> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
p {
margin: 0 0 0.75rem;
} const preiseInCent = [1290, 450, 9900];
let summeInCent = 0;
for (let i = 0; i < preiseInCent.length; i++) {
console.group(`Durchlauf ${i}`);
console.log("Preis:", preiseInCent[i]);
console.log("Summe vorher:", summeInCent);
summeInCent = summeInCent + preiseInCent[i];
console.log("Summe nachher:", summeInCent);
console.groupEnd();
}
console.log("Endsumme:", summeInCent); Bei zwanzig Durchläufen ist die Console ohne Gruppen eine Wand aus Zeilen. Mit Gruppen ist sie eine Liste zum Aufklappen. Die Console dieses Kurses zeigt beides richtig an, die Tabelle als Tabelle und die Gruppen zum Auf- und Zuklappen, und ein Objekt kannst du dort genauso aufklappen wie in den Entwicklerwerkzeugen des Browsers.
Haltepunkte
Irgendwann reicht console.log nicht mehr. Das ist dann der Fall, wenn du nicht weißt, wonach du suchst, denn eine Ausgabe zeigt immer nur, was du vorher ausgewählt hast.
Ein Haltepunkt hält das Programm an einer Zeile an, mitten im Lauf. Dann siehst du jede Variable, die dort gilt, mit ihrem echten Wert. Gesetzt wird er in den Entwicklerwerkzeugen des Browsers, und ein debugger; im Code tut dasselbe, sobald sie offen sind.
Der Reiter Debug
Anhalten geht hier nicht. Was ein Haltepunkt eigentlich beantwortet, ist aber die Frage, was in diesem Moment in den Variablen stand. Und die beantwortet auch der Reiter „Debug“ aus Lektion 4.1.
Dort hast du damit einer Schleife beim Zählen zugesehen. Hier ist er das Werkzeug beim Fehlersuchen, derselbe Handgriff mit einer anderen Absicht. Statt console.log-Zeilen einzubauen, genügt ein Druck auf „Aufzeichnen“, und danach blätterst du durch die Liste. In der Aufgabe kannst du so in der Schleife nachsehen, welchen Wert i in jedem Durchlauf hat, und im Code steht hinterher keine einzige Zeile, die wieder herausmüsste.
Drei Grenzen gibt es, und die dritte ist die unangenehme. Aufgezeichnet wird die Datei, an der du arbeitest. Solange der Code einen Syntaxfehler hat, wird gar nichts aufgezeichnet, dann steht die Meldung in der Console, und die kommt zuerst. Und bei einer Schleife, die wirklich nie endet, hilft der Reiter nicht. Dann hängt die ganze Seite samt Reiter, und daran ändert kein Werkzeug etwas. Gedeckelt ist nur die sehr lange, aber endliche Schleife. Nach zweitausend Schritten hört die Aufzeichnung auf, und das steht dann auch da.
Warten geht im Reiter nicht. Bei einem Haltepunkt steht das Programm, und du siehst dich in Ruhe um, bevor es weitergeht. Hier läuft alles durch, und nachgesehen wird hinterher. Für die meisten Fehler reicht das. Für alles andere gibt es die Entwicklerwerkzeuge, und Lektion 20.5 zeigt den Weg dorthin.
Der eigene Code steht dort übrigens sehr wohl, nur nicht als app.js. Er landet in einem zusammengebauten Dokument, und vor deiner ersten Zeile stehen weit über tausend Zeilen der Lektionsansicht. Ein debugger; hält also wirklich an, sobald die Entwicklerwerkzeuge offen sind. Bequem ist es nicht.
Halbieren
<p>Vier Schritte, ein falsches Ergebnis. Wo geht es schief?</p> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
p {
margin: 0 0 0.75rem;
} function schritt1(text) {
return text.trim();
}
function schritt2(text) {
return text.split(",");
}
function schritt3(teile) {
return teile.map((teil) => Number(teil));
}
function schritt4(zahlen) {
return zahlen.reduce((a, b) => a + b, 0);
}
const eingabe = " 10, 20, dreißig ";
// Nicht raten, sondern nachsehen. Eine Zeile je Zwischenstand.
const a = schritt1(eingabe);
console.log("nach schritt1:", a);
const b = schritt2(a);
console.log("nach schritt2:", b);
const c = schritt3(b);
console.log("nach schritt3:", c);
const d = schritt4(c);
console.log("nach schritt4:", d); Wer nicht weiß, wo der Fehler ist, halbiert den Code, bis er es weiß. Das ist der ehrlichste Rat dieses Kurses.
Eine Kette aus vier Schritten liefert am Ende etwas Falsches. Statt alle vier durchzulesen, reicht ein Blick auf den Zwischenstand nach Schritt 2. Stimmt er, liegt das Problem in der zweiten Hälfte. Stimmt er nicht, liegt es in der ersten, und dann wird wieder halbiert.
In einer Kette aus zwanzig Schritten ist die Stelle nach vier, höchstens fünf Halbierungen gefunden. Durch Lesen vielleicht auch, aber dann weißt du hinterher nie, ob du wirklich alles gesehen hast.
Im dritten Beispiel steht dreißig in den Daten, und Number("dreißig") ist NaN. Die Ausgabe nach Schritt 3 zeigt es sofort. Ohne die Zwischenstände steht am Ende nur NaN da, und du suchst genauso gut in reduce.
Der letzte Trick
Wenn gar nichts mehr hilft, erkläre ich das Problem laut. Einer Kollegin, einem Kuscheltier, dem leeren Raum. Erstaunlich oft löst sich der Fehler schon beim zweiten Satz.
Das Verfahren hat sogar einen Namen, Rubber-Duck-Debugging, nach einer Anekdote aus dem Buch „The Pragmatic Programmer“, in der jemand einer Gummiente seinen Code erklärt. Beim Erklären sprichst du Annahmen aus, die du beim Lesen einfach überspringst, und deshalb funktioniert es.
In der Aufgabe stecken drei Fehler in einer Funktion, die nie eine Meldung wirft.
Zum Mitnehmen
Erst die Meldung lesen, dann die genannte Zeile ansehen, dann die Werte prüfen. Beschriftete Ausgaben und der Reiter Debug zeigen diese Werte, und ohne jede Spur führt das Halbieren der Kette zur Stelle.
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 3 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe im Editor, direkt im Browser geprüft
Öffnet sich mit dem Basis Konto.