Abschnitt 18 · Lektion 3
Debuggen
Stürzt ein Programm ab, zeigt der Stacktrace die Stelle. Rechnet es nur falsch, zeigt dir niemand
etwas. Wer die Stelle dann mit console.log sucht, verteilt Ausgaben, bis eine etwas Unerwartetes
zeigt. Das klappt nur, wenn eine davon zufällig an der richtigen Stelle steht.
Umwandlungen, die nicht werfen
// Sechs Werte, drei Umwandlungen. Keine davon wirft, keine warnt.
const proben = ["1.299,00", "", " ", "08", "12.5kg", undefined];
for (const roh of proben) {
console.log(
`${JSON.stringify(roh)}`.padEnd(10),
"Number:", String(Number(roh)).padEnd(6),
"parseFloat:", String(Number.parseFloat(roh)).padEnd(6),
"parseInt:", String(Number.parseInt(roh, 10))
);
}
const preis = Number.parseFloat("1.299,00");
console.log("");
console.log("Zwei Stück zu 1.299,00 kosten laut Programm:", preis * 2); JavaScript wirft bei diesen Umwandlungen nicht. Es liefert NaN, 0 oder eine halb gelesene Zahl,
und das Programm rechnet damit weiter. Der erste Fall kostet Geld, und zwar still. parseFloat hält
den Punkt für das Dezimalzeichen und hört am Komma auf, aus 1.299,00 wird also 1,299.
Mit einer Ausgabe findest du so etwas nur dort, wo du sie hinsetzt. Ein Haltepunkt (englisch breakpoint) hält das Programm an einer Zeile an und zeigt alle Variablen auf einmal, auch die, an die vorher niemand gedacht hat.
node —inspect und was dabei passiert
Mit node --inspect index.js öffnet der Prozess zusätzlich einen Zugang und schreibt eine Adresse
auf den Fehlerkanal. Daran hängen sich der Editor oder die Entwicklerwerkzeuge des Browsers. Dann
gibt es dasselbe wie im Browser, also Haltepunkte, eine Ansicht der Variablen und schrittweises
Weitergehen.
--inspect-brk hält schon vor der ersten Zeile an. Das brauchst du, wenn der Fehler beim Start
passiert. Mit --inspect allein ist das Programm sonst längst durch, bevor sich jemand verbunden
hat.
Der Zugang ist offen, und wer sich verbindet, darf beliebigen Code im Prozess ausführen. Im Betrieb
hat --inspect deshalb nichts verloren, auf dem eigenen Rechner stört es niemanden.
console.log bleibt trotzdem oft die bessere Wahl. Manchmal passiert etwas hundertmal, und du
willst sehen, wie sich ein Wert über die Durchläufe entwickelt. Dann ist ein Haltepunkt hundertmal
lästig, und eine Ausgabe ist einmal geschrieben.
In der Sandbox geht nur die erste Hälfte
node --inspect rechnung.js liegt in der Befehlsleiste der Aufgabe. Auf dem Fehlerkanal stehen
danach zwei Zeilen, Debugger listening on ws://127.0.0.1:9229/… mit einer Kennung, die bei jedem
Start anders ist, und ein Verweis auf die Anleitung. Dann läuft das Programm wie sonst weiter und
gibt seine Summe aus, so wie auf dem eigenen Rechner auch.
Verbinden kann sich hier allerdings niemand. Die Adresse zeigt auf 127.0.0.1 in der Sandbox. Aus
dieser Maschine führt nur ein Port nach draußen, nämlich der, auf dem im Reiter Browser die Seite
steht. Mit node --inspect-brk rechnung.js bleibt es bei den beiden Zeilen. Der Prozess wartet auf
jemanden, der sich verbindet, bis ihn nach dreißig Sekunden das Zeitlimit des Terminals beendet.
Danach schreibt das Terminal noch einen Satz über „Sandbox starten“. Der ist eigentlich für Server
gedacht, und Debugger listening sieht für das Terminal eben aus wie einer. Einen offenen
Debugger-Zugang hat die Sandbox aus demselben Grund nicht, aus dem er im Betrieb nichts verloren
hat.
Der Reiter Debug
Die Frage, für die man anhält, lässt sich trotzdem beantworten, und zwar im Reiter Debug. Nach Aufzeichnen steht dort für jede Zeile, was in diesem Moment in den Variablen stand, und beim Blättern springt der Editor mit.
Beim Beispiel „Halbieren statt raten“ weiter unten sind es 26 Schritte. In der Schleife von laufe
steht bei jedem Schritt, wie wert gerade aussieht. Nach dem dritten Durchlauf steht dort
"grüße-aus-köln", nach dem vierten "gre-aus-kln". Die Umlaute gehen also im vierten Schritt
verloren, und dafür musste keine zusätzliche Ausgabe in den Code.
Aufgezeichnet wird die Datei, die im Editor vorn liegt. Eine Aufzeichnung ist ein eigener Lauf und kostet wie jeder andere. Die Prüfliste füllt sie nicht.
Halbieren, prüfen, halbieren
// Fuenf Schritte, ein falsches Ergebnis am Ende.
const schritte = [
(wert) => wert.trim(),
(wert) => wert.toLowerCase(),
(wert) => wert.replaceAll(" ", "-"),
(wert) => wert.replaceAll(/[^a-z0-9-]/g, ""),
(wert) => wert.replaceAll(/-+/g, "-"),
];
function laufe(eingabe, bis) {
let wert = eingabe;
for (let i = 0; i < bis; i++) {
wert = schritte[i](wert);
}
return wert;
}
const eingabe = " Grüße aus Köln ";
// Nicht vorn anfangen, sondern in der Mitte: Ist das Ergebnis nach
// drei Schritten noch gut, liegt der Fehler hinten.
console.log("nach 3 von 5:", JSON.stringify(laufe(eingabe, 3)));
console.log("nach 4 von 5:", JSON.stringify(laufe(eingabe, 4)));
console.log("nach 5 von 5:", JSON.stringify(laufe(eingabe, 5))); Halbieren fühlt sich langsamer an als Raten. Zwischen „hier ist es noch richtig“ und „hier ist es falsch“ schaust du auf halber Strecke nach, und danach ist die Strecke halb so lang. Bei fünf Schritten sind es so höchstens drei Blicke statt vier, bei zwanzig höchstens fünf statt neunzehn.
Das geht nicht nur mit Zeilen. Dasselbe klappt mit Commits, die git bisect von selbst halbiert,
und mit Eingabedaten, wenn man die Hälfte der Zeilen weglässt.
Ausgaben, die etwas sagen
const zeile = 2490;
const summe = 6215;
// Drei Ausgaben derselben Zahlen. Die erste sagt nicht, was sie sind.
console.log(zeile);
console.log("zeile", zeile, "summe", summe);
console.log({ zeile, summe });
// Und der Kanal zaehlt: Wer beim Suchen console.error nimmt, findet
// seine Zeilen auch dann wieder, wenn stdout weitergeleitet wird (4.3).
console.error("suche: hier bin ich"); Wenn es doch eine Ausgabe wird, dann eine, die man später noch lesen kann.
console.log({ zeile, summe }) schreibt die Namen gleich mit, für zwei geschweifte Klammern mehr
als console.log(zeile, summe). Bei mehreren gleich gebauten Objekten zeigt console.table sie als
Tabelle mit einer Spalte je Eigenschaft.
Suchausgaben schreibe ich mit console.error. Sie stehen dann auf dem Fehlerkanal, getrennt von
allem, was das Programm sonst ausgibt, und node index.js > /dev/null zeigt sie allein. Das ist der
Fehlerkanal aus Lektion 4.3, angewendet auf die eigene Suche.
node —watch
node --watch index.js startet ein Programm neu, sobald sich eine Datei ändert, die es geladen hat.
Dafür gab es jahrelang nodemon. Seit Node 22 ist --watch stabil, und ein Projekt wie die in
diesem Kurs braucht das Paket nicht mehr. Zusammen mit --inspect ergibt das eine Arbeitsumgebung
ohne eine einzige Abhängigkeit.
Auch davon gibt es in der Sandbox nur die eine Hälfte. Mit node --watch rechnung.js steht nach dem
Durchlauf Completed running 'rechnung.js'. Waiting for file changes before restarting... im
Terminal. Weiter kommt es nicht, bis nach dreißig Sekunden das Zeitlimit greift. Ändern müsstest du
die Datei im Editor, aber solange ein getippter Befehl läuft, hält die laufende Sandbox still und
spielt nichts ein. Zu Hause speichert der Editor die Datei, und dann folgen Change detected und
Restarting 'rechnung.js'.
Auch die Rechnung im Reiter Praxis stürzt nicht ab, sie kommt nur auf den falschen Betrag.
Zum Mitnehmen
Eine Stelle zu finden heißt, das Programm anzuhalten und in seinen Zustand zu schauen. In der Sandbox ersetzt der Reiter Debug das Anhalten, und wer die Stelle sucht, halbiert die Strecke, statt zu raten.
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.
In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.
Was in dieser Lektion steckt
-
Artikel mit 3 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe, dein Code läuft auf einem Server
Öffnet sich mit dem Basis Konto.