mitmario.dev

Synthese: die Bestenliste

JavaScript Im Browser 3 Min Lesezeit 4 BeispieleLektion 9 von 10

Für eine Bestenliste wird ausgesiebt, sortiert und aus jedem Eintrag eine Zeile gemacht. Das sind drei Schritte hintereinander. Mit drei Zwischennamen stehen dafür drei Zeilen da, und jeder Name wird nur ein einziges Mal gebraucht. Die Methoden aus diesem Abschnitt lassen sich stattdessen direkt aneinanderhängen.

Warum das Verketten funktioniert

Warum sich die Methoden verketten lassen
const zahlen = [3, 12, 5, 20, 1, 9];

// In Einzelschritten, mit einem Namen für jede Stufe.
const grosse = zahlen.filter((zahl) => zahl > 4);
const sortiert = grosse.sort((a, b) => b - a);
const beschriftet = sortiert.map((zahl) => `Wert: ${zahl}`);
console.log("Einzeln:", beschriftet);

// Dasselbe als Kette. Jede Stufe gibt eine Liste zurück, deshalb
// darf die nächste direkt dahinter stehen.
const kette = zahlen
  .filter((zahl) => zahl > 4)
  .sort((a, b) => b - a)
  .map((zahl) => `Wert: ${zahl}`);

console.log("Als Kette:", kette);

filter, sort und map geben wieder eine Liste zurück, und auf einer Liste lässt sich die nächste Methode aufrufen. Damit fallen die Zwischennamen weg, und die Stufen hängen direkt aneinander. Der Punkt am Zeilenanfang ist derselbe Punkt wie immer, nur umgebrochen.

Üblich ist eine Stufe je Zeile. So liest du die Kette von oben nach unten wie einen Ablauf. Erst das, dann das, dann das.

reduce ist die Ausnahme. Es gibt meistens einen einzelnen Wert zurück, eine Zahl oder einen Text, und steht deshalb meistens am Ende einer Kette.

Die Reihenfolge

Die Reihenfolge der Kette
const zahlen = [3, 12, 5, 20, 1, 9];

// Erst aussortieren, dann umformen: map fasst nur noch drei an.
const richtig = zahlen
  .filter((zahl) => zahl > 8)
  .map((zahl) => {
    console.log("map arbeitet an", zahl);
    return zahl * 2;
  });

console.log("Ergebnis:", richtig);
console.log("---");

// Andersherum: map fasst alle sechs an, filter wirft danach
// die Hälfte weg. Dasselbe Ergebnis, doppelte Arbeit.
const teurer = zahlen
  .map((zahl) => {
    console.log("map arbeitet an", zahl);
    return zahl * 2;
  })
  .filter((zahl) => zahl > 16);

console.log("Ergebnis:", teurer);

Üblich ist erst filter, dann sort, dann map. Nur filter macht die Liste kürzer, und je weiter vorn es steht, desto weniger Arbeit bleibt für den Rest. sort steht vor map, weil nach dem Umformen oft nur noch Text übrig ist. Nach Text lassen sich Punkte nicht mehr sortieren.

Wird zuerst gefiltert, formt map nur noch die drei übrigen um. Wird zuerst umgeformt, fasst map alle sechs an, und filter wirft die Hälfte danach weg. Das Ergebnis ist dasselbe, die Arbeit doppelt. Im Beispiel siehst du das an den Ausgaben aus dem map-Callback, einmal drei Zeilen, einmal sechs.

sort verändert die Liste, auf der es steht. Steht davor ein filter, ist das harmlos, denn filter hat schon eine neue Liste erzeugt, und deshalb steht im ersten Beispiel auch kein slice dazwischen. Steht sort direkt auf dem Original, sortiert es das Original um.

Wann eine Kette zu lang ist

Wenn die Kette zu lang wird
// Bestellungen: vorn die Nummer, dahinter der Betrag in Cent.
const bestellungen = [
  [1041, 4590],
  [1042, 1290],
  [1043, 8800],
  [1044, 350],
];

// Vier Stufen am Stück. Läuft, und beim Suchen eines Fehlers
// weiß man nicht, welche Stufe schuld ist.
console.log(
  bestellungen
    .filter((b) => b[1] >= 1000)
    .sort((x, y) => y[1] - x[1])
    .slice(0, 2)
    .map((b) => `Bestellung ${b[0]}`)
);

// Mit Zwischenschritten. Jeder hat einen Namen, jeder ist
// einzeln ausgebbar.
const ueberZehnEuro = bestellungen.filter((b) => b[1] >= 1000);
// slice, weil ueberZehnEuro unten noch unsortiert ausgegeben wird.
const nachBetrag = ueberZehnEuro.slice().sort((x, y) => y[1] - x[1]);
const groessteZwei = nachBetrag.slice(0, 2);

console.log("Über 10 Euro:", ueberZehnEuro);
console.log("Sortiert:", nachBetrag);
console.log("Fertig:", groessteZwei.map((b) => `Bestellung ${b[0]}`));

Eine Kette darf beliebig lang werden, und ab einer bestimmten Länge sollte sie es nicht mehr. Lässt sich in einem Satz sagen, was hier passiert? Wenn nicht, zerlege ich sie in benannte Zwischenschritte, wie bei den Funktionen im letzten Abschnitt.

Das bringt vor allem etwas beim Suchen eines Fehlers. Stimmt das Ergebnis nicht, kannst du jeden Zwischenschritt einzeln ausgeben und siehst sofort, welche Stufe schuld ist. In einer Kette am Stück geht das nicht ohne Umbau.

Bis drei Stufen schreibe ich eine Kette, ab vier lohnt ein Zwischenname. Wird eine Stufe selbst kompliziert, bekommt sie eine eigene Funktion.

Lesbar, nicht schneller

Lesbar, nicht schneller
const zahlen = [3, 12, 5, 20, 1, 9];

// Die Kette läuft dreimal über die Daten: einmal je Stufe.
const mitKette = zahlen
  .filter((zahl) => zahl > 4)
  .map((zahl) => zahl * 2)
  .reduce((summe, zahl) => summe + zahl, 0);

console.log("Mit Kette:", mitKette);

// Die Schleife läuft einmal und ist damit sparsamer. Und sie
// ist schwerer zu lesen, weil drei Gedanken darin stecken.
let mitSchleife = 0;
for (const zahl of zahlen) {
  if (zahl > 4) {
    mitSchleife = mitSchleife + zahl * 2;
  }
}

console.log("Mit Schleife:", mitSchleife);

// Bei sechs Einträgen ist der Unterschied nicht messbar. Bei
// Millionen wäre er es, und dann rechnet man nach, statt zu raten.

Eine Kette ist nicht schneller als eine Schleife. Meistens ist sie sogar langsamer, denn jede Stufe läuft einmal über die Daten und legt eine neue Liste an, und die Schleife läuft dagegen nur ein einziges Mal.

Der Grund für die Kette ist die Lesbarkeit. In der Schleife stecken drei Gedanken in vier Zeilen, und du musst sie erst auseinandersortieren. In der Kette steht jeder Gedanke in einer eigenen Zeile, mit einem Namen davor.

Bei den Listengrößen auf einer Webseite ist der Unterschied nicht messbar. Wird er es doch einmal, misst man nach, statt zu raten.

In der Aufgabe wird aus acht Ergebnissen eine Bestenliste, und die erste Funktion ist eine Kette.

Zum Mitnehmen

Eine Kette funktioniert, weil filter, sort und map wieder eine Liste zurückgeben. filter steht vorn, weil es die Liste kürzer macht, und eine Kette ist lesbarer als eine Schleife, nicht schneller.

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.