Höhere Funktionen und Rekursion in JavaScript

Zwei fortgeschrittene, eng verwandte Funktionskonzepte: Funktionen, die andere Funktionen als Parameter nehmen oder zurückgeben ("Higher-Order Functions", die wir mit map/filter/reduce aus Kapitel 11 bereits täglich nutzen), und Funktionen, die SICH SELBST aufrufen (Rekursion).

Was ist eine Higher-Order Function?

Eine Funktion ist "höher", wenn sie mindestens EINE der beiden Eigenschaften hat: Sie nimmt eine Funktion als Argument entgegen, ODER sie gibt eine Funktion zurück.

// Nimmt eine Funktion als Argument entgegen:
function verarbeiteTransaktionen(transaktionen, verarbeitungsFunktion) {
  return transaktionen.map(verarbeitungsFunktion);
}

const betraege = verarbeiteTransaktionen(
  [{ betrag: 2400 }, { betrag: -850 }],
  t => t.betrag
);
console.log(betraege); // [2400, -850]

Funktionen, die Funktionen zurückgeben

Ein mächtiges Muster: eine Funktions-FABRIK, die auf Basis eines Parameters eine spezialisierte Funktion erzeugt – für unser Haushaltsbuch etwa eine Fabrik für Kategorie-Filter:

function erstelleKategorieFilter(kategorie) {
  return function (transaktion) {
    return transaktion.kategorie === kategorie;
  };
}

const transaktionen = [
  { beschreibung: 'Miete', kategorie: 'Wohnen', betrag: -850 },
  { beschreibung: 'Strom', kategorie: 'Wohnen', betrag: -60 },
  { beschreibung: 'Kino', kategorie: 'Freizeit', betrag: -18 },
];

const istWohnkosten = erstelleKategorieFilter('Wohnen'); // GENAU wie Kapitel 16: ein Closure!
const wohnkosten = transaktionen.filter(istWohnkosten);

console.log(wohnkosten); // Miete und Strom

Tipp: Das ist derselbe Closure-Mechanismus aus Kapitel 16 – höhere Funktionen und Closures gehen in der Praxis oft Hand in Hand: Die zurückgegebene Funktion "merkt sich" den kategorie-Parameter der äußeren Funktion.

Funktionskomposition: kleine Funktionen kombinieren

const nurAusgaben = transaktionen => transaktionen.filter(t => t.betrag < 0);
const summiereBetraege = transaktionen => transaktionen.reduce((s, t) => s + t.betrag, 0);

function berechneAusgabenSumme(transaktionen) {
  return summiereBetraege(nurAusgaben(transaktionen));
}

console.log(berechneAusgabenSumme(transaktionen)); // -928

Rekursion: eine Funktion ruft sich selbst auf

Eine rekursive Funktion braucht IMMER zwei Teile: einen Basisfall ("wann hört die Rekursion auf?"), und einen rekursiven Fall, der das Problem verkleinert und sich selbst erneut aufruft:

function fakultaet(n) {
  if (n <= 1) {
    return 1; // Basisfall
  }
  return n * fakultaet(n - 1); // rekursiver Fall - verkleinertes Problem
}

console.log(fakultaet(5)); // 120 (5 * 4 * 3 * 2 * 1)

Achtung: Fehlt der Basisfall oder wird er nie erreicht, führt das zu unendlicher Rekursion und einem "Maximum call stack size exceeded"-Fehler, sobald der Call Stack (Kapitel 23) voll ist.

Praxisbeispiel: verschachtelte Kategorie-Baumsummen

Rekursion eignet sich besonders für Baumstrukturen – z. B. wenn Kategorien Unterkategorien haben dürfen:

src/index.js

const kategorienBaum = {
  name: 'Alle Ausgaben',
  betrag: 0,
  unterkategorien: [
    { name: 'Wohnen', betrag: -910, unterkategorien: [] },
    {
      name: 'Freizeit', betrag: 0,
      unterkategorien: [
        { name: 'Kino', betrag: -18, unterkategorien: [] },
        { name: 'Sport', betrag: -35, unterkategorien: [] },
      ],
    },
  ],
};

function summiereBaum(knoten) {
  let summe = knoten.betrag;
  for (const unterkategorie of knoten.unterkategorien) {
    summe += summiereBaum(unterkategorie); // rekursiver Aufruf pro Ebene
  }
  return summe;
}

console.log(summiereBaum(kategorienBaum)); // -963