Abschnitt 14 · Lektion 5
Synthese: gegen falsche Eingaben härten
Eine Auswertung bekommt ihre Daten aus einem Formular, und eines Tages steht in einem Feld zehn statt 10. Oder die Liste ist leer. Oder es kommt gar keine. Sobald Daten von außen kommen, aus einem Formular, aus dem Netz oder aus dem Speicher des Browsers, ist falsch der Normalfall. Robust heißt, dass eine Funktion dann trotzdem etwas Sinnvolles tut.
Die drei Fragen
<p>Dieselben Eingaben gehen an beide Fassungen, die naive und die gehärtete. Die Ausgaben stehen in der Console.</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;
} // Naiv: funktioniert, solange alles stimmt.
function schnittNaiv(zahlen) {
let summe = 0;
for (const zahl of zahlen) {
summe = summe + zahl;
}
return summe / zahlen.length;
}
// Gehärtet: dieselbe Rechnung, mit zwei Antworten vorher.
function schnittHart(zahlen) {
if (!Array.isArray(zahlen)) {
throw new Error(`Liste erwartet, bekommen: ${typeof zahlen}`);
}
if (zahlen.length === 0) {
return 0;
}
let summe = 0;
for (const zahl of zahlen) {
summe = summe + zahl;
}
return summe / zahlen.length;
}
console.log("naiv, leer:", schnittNaiv([]));
console.log("hart, leer:", schnittHart([]));
try {
console.log("naiv, null:", schnittNaiv(null));
} catch (fehler) {
console.error("naiv wirft von selbst:", fehler.message);
}
try {
schnittHart(null);
} catch (fehler) {
console.error("hart wirft mit Ansage:", fehler.message);
} Fast jede Funktion lässt sich mit drei Fragen härten, und die Reihenfolge ist immer dieselbe.
- Was, wenn gar nichts kommt, also
undefined,nulloder ein fehlendes Argument? - Was, wenn etwas vom falschen Typ kommt, ein Text, wo eine Zahl erwartet wird, ein Objekt, wo eine Liste erwartet wird?
- Was, wenn die Menge leer ist, eine Liste ohne Einträge, ein Text ohne Zeichen?
Im ersten Beispiel steht dieselbe Rechnung zweimal. Die naive Fassung liefert bei einer leeren Liste NaN. Bei null wirft sie einen TypeError wie zahlen is not iterable, und der nennt zwar den Namen, sagt aber nicht, was die Funktion erwartet hätte. Die gehärtete Fassung liefert 0 und wirft eine Meldung, die den Fall beim Namen nennt.
Bei gültigen Daten „funktionieren“ beide gleich gut. Den Unterschied siehst du erst, wenn es klemmt. Dann aber deutlich.
Sonderfälle nach oben
Die Prüfungen stehen ganz oben in der Funktion, und jede steigt sofort aus. Das ist der frühe Ausstieg aus Lektion 5.3, und hier zählt er besonders.
Sind die Sonderfälle oben abgehandelt, hat es der Rest der Funktion nur noch mit gültigen Daten zu tun. Dort muss nichts mehr geprüft werden, und die Rechnung kann geradeaus laufen.
Sonst müsstest du die eigentliche Rechnung in ein if packen und immer weiter verschachteln. Nach dem dritten Sonderfall liest das niemand mehr.
Überspringen oder abbrechen
<p>Ein fauler Eintrag in der Liste. Zwei Umgangsweisen.</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 eingang = [
{ punkte: 10 },
{ punkte: "zehn" },
{ punkte: 30 },
];
// Streng: ein fauler Eintrag bringt alles zu Fall.
function summeStreng(liste) {
return liste.reduce((summe, eintrag) => {
if (typeof eintrag.punkte !== "number") {
throw new Error(`punkte muss eine Zahl sein, bekommen: ${typeof eintrag.punkte}`);
}
return summe + eintrag.punkte;
}, 0);
}
// Nachsichtig: was nicht passt, wird gezählt und übersprungen.
function summeNachsichtig(liste) {
let uebersprungen = 0;
const summe = liste.reduce((zwischenstand, eintrag) => {
if (typeof eintrag.punkte !== "number") {
uebersprungen = uebersprungen + 1;
return zwischenstand;
}
return zwischenstand + eintrag.punkte;
}, 0);
console.warn("Übersprungen:", uebersprungen);
return summe;
}
try {
console.log("streng:", summeStreng(eingang));
} catch (fehler) {
console.error("streng bricht ab:", fehler.message);
}
console.log("nachsichtig:", summeNachsichtig(eingang)); Mit einem faulen Eintrag in einer Liste kann man auf zwei Arten umgehen. Je nach Lage ist jede davon richtig.
Abbrechen passt, wenn ein Teilergebnis nichts wert ist. Eine Rechnungssumme, in der eine Position fehlt, ist schlimmer als gar keine Summe, denn sie sieht richtig aus.
Überspringen passt, wenn das Ergebnis auch ohne den Eintrag brauchbar bleibt. Eine Statistik über tausend Messwerte ist nicht wertlos, nur weil drei davon Unsinn sind.
In beiden Fällen mache ich das Übergehen sichtbar. Im Beispiel zählt die nachsichtige Fassung die übersprungenen Einträge und meldet sie mit console.warn. Stilles Überspringen kostet dich ein halbes Jahr später die Nerven.
Wo die Grenze liegt
<p>Nur eine der drei Funktionen prüft, und das reicht.</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;
} // An der Grenze: prüft, weil hier fremde Daten ankommen.
function preisAnzeigen(rohwert) {
const cent = Number(rohwert);
if (!Number.isFinite(cent) || cent < 0) {
throw new Error(`Preis in Cent erwartet, bekommen: ${rohwert}`);
}
return formatieren(inEuro(cent));
}
// Intern: verlässt sich auf den Aufrufer. Kein zweites Netz.
function inEuro(cent) {
return cent / 100;
}
// Ebenfalls intern.
function formatieren(euro) {
return euro.toFixed(2).replace(".", ",") + " Euro";
}
console.log(preisAnzeigen("4900"));
console.log(preisAnzeigen(1990));
try {
preisAnzeigen("vier Euro");
} catch (fehler) {
console.error(fehler.message);
} Nicht jede Funktion muss jede Eingabe überleben. Wer das versucht, bekommt Code, in dem die Hälfte aller Zeilen Prüfungen sind, die nie zuschlagen.
Geprüft wird an der Grenze zur Außenwelt, innen nicht. Die Funktion, in die fremde Daten hineingehen, prüft sie. Was sie danach weiterreicht, ist geprüft, und die internen Helfer dürfen sich darauf verlassen.
Im dritten Beispiel prüft nur preisAnzeigen, und Number.isFinite sagt dort, ob eine echte, endliche Zahl herauskam. inEuro und formatieren bekommen nie etwas anderes zu sehen als eine gültige Zahl, denn vor ihnen hat schon jemand aufgepasst.
So ist auch der Rest dieser Seite gebaut. Jede Anfrage von außen wird an der Systemgrenze einmal geprüft, danach vertraut der Code sich selbst. Doppelt prüfen bringt keine zusätzliche Sicherheit, nur zusätzliche Stellen, die auseinanderlaufen können.
Wann es genug ist
Gegen alles gewappnet ist eine Funktion nie, irgendein Fall lässt sich immer noch finden. Ich frage stattdessen, ob es jemand merkt, wenn hier etwas schiefgeht, und ob er dann weiß, wo er suchen muss. Ist beides der Fall, ist die Funktion robust genug.
In der Aufgabe härtest du eine Auswertung gegen alle drei Fragen, und faule Einträge werden übersprungen.
Zum Mitnehmen
Drei Fragen härten fast jede Funktion, was passiert, wenn nichts kommt, wenn etwas vom falschen Typ kommt und wenn die Menge leer ist. Geprüft wird an der Grenze zur Außenwelt, und was übersprungen wird, bleibt sichtbar.
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.