Rekursive Funktionen in Javascript

Rekursiv statt while Schleife, Mittelwert Rekursion

In der Programmierung nennt man Funktion, die sich selbst aufrufen, rekursive Funktionen. Rekursionen sind ein Konzept, dass es in jeder Programmiersprache gibt.

Rekursionen wiederholen Anweisungen in einer immer wieder gleichen Art und Weise. Berühmte Beispiele sind Quicksort, die Berechnung der Fakultät einer Zahl, von Fibonacci-Zahlen und das Durchlaufen von Baumstrukturen.

Rekursionen anstelle von while-Schleifen

Rekursive Funktionen werden meist mit mathematisch interessanten Beispielen bestückt, so dass viele Entwickler Rekursionen eher für ein Thema am Rande ansehen, das fürs Scripting in Webseiten irrelevant ist. Dabei sind rekursive Funktionen eine Alternative zu while-Schleifen und fast immer einfacher, verständlicher und effizienter.

Hier erlaubt eine kleine Rekursion, dass der Benutzer beliebig viele Felder erzeugt, um den Mittelwert einer Zahlenreihe zu berechnen.

function newField() {
   document.getElementById('wert').addEventListener("focus", function getFocus() {
      let newInput = this.cloneNode(true);
      this.parentNode.appendChild(newInput);
      this.removeAttribute("id");
      this.removeEventListener("focus", getFocus);
      newField();
   });
}

newField();

Wie lang oder wie oft die Rekursion durchgeführt wird, muss innerhalb der Funktion gesteuert werden: Damit die Rekursion endet, braucht sie eine Bedingung und darf beim Eintreffen nicht erneut aufgerufen werden. Ansonsten kommt die große unendliche Schleife …

In diesem Beispiel ist der Abbruch ganz einfach: Die Rekursion wird nur ausgeführt, wenn der Benutzer ein Feld anklickt, um den nächsten Wert einzugeben.

Fakultät und Kombination K aus N

Ein einfaches Beispiel für rekursive Funktionen ist die Fakultät einer Zahl (in der Mathematik als n! geschrieben). Die Fakultät ist das Produkt aller positiven Zahlen, die kleiner oder gleich der Zahl n sind.

Fakultät von n oder n! wird z.B. zur Berechnung von Permutationen herangezogen – etwa »wie kann ich 5 unterschiedliche Objekte in einer Reihe anordnen?«

function fakultaet (n) {
    if ( n<=1 ) {
    	console.log ( n );
        return n;
    }
    console.log ( n ' * ' );
    return n * fakultaet( n - 1 );
}

console.log ("Resulat " + fakultaet(5));

Die Ausgabe läßt sich in der Javascript-Console des Browsers nachvollziehen:

5 *
4 *
3 *
2 *
1
Resultat: 120

Oder das etwas praktischere Beispiel: "Wie viele Kombinationen von Karten erwarten den Skatspieler (der eine Kombination von 12 Karten aus 32 Karten bekommt)?

Prominente Vertreter der rekursiven Funktionen sind requestAnimationFrame und setTimeout: Animationen führen kleine Schritte aus und rufen sich selbst für die Dauer der Animation auf.

Der Shooting Star ist Quicksort – der Sortieralgorithmus, den auch array.sort() benutzt.

Selbstausführende rekursive Funktionen

Anstelle der gradlinigen Funktion sieht man rekursive Funktionen in Javascript häufig als Funktionsaufruf oder function expression oder sofort ausgeführte anonyme Funktion oder self invoking function. Das macht die Rekursion deutlicher und im Quelltext besser nachvollziehbar.

let result = (function computeFactorial (number) {
   if (number <= 1) {
      return 1;
   }
   return number * computeFactorial (number - 1 );
} (5) );

console.log ('Result ' + result);

Man beachte die runden Klammern rund um die komplette Funktion!

Alle Tags der Webseite

Nie waren rekursive Funktionen so wertvoll wie heute, da die Baumstruktur des DOM nach eleganten Verfahren zur Analyse des DOM-Baums ruft.

DOM Tree – Baumstrukturhtmlheadbodytitlemetanavdivformulsectionsectionh1p
document.getElementById('counttags').onclick = function () {
   countTags.counter = 0;
   let allTags = new Array();
   let result = document.getElementById('result');
   
   function countTags(obj) {
      let elems = obj.childNodes;
      countTags.counter++;
      for (let i=0; i<elems.length; i++) {
         if (elems[i].nodeType == 1) {
            allTags.push(elems[i].nodeName);
            countTags(elems[i]);
         }
      }
      result.textContent = allTags.length;
   }
   countTags (document.body);
}

In countTags(obj) sitzt die Rekursion: Die Funktion erwartet einen Elementknoten als Argument und liest als erstes alle Kindknoten des Arguments in das Array elems.

In der for-Anweisung sieht sich die Funktion jeden Kindknoten an und wenn ein Kindknoten ein Elementknoten ist (if (elems[i].nodeType == 1)), der selber wieder Kindknoten haben kann, legt die Anweisung allTags.push(elems[i].nodeName); den Namen des Elementknotens im globalen Array allTags ab und ruft sich selbst mit dem Elementknoten auf.

Das war's schon. Rekursionen sind fast immer im wahrsten Sinne des Wortes „unvorstellbar“ banal.

Am Rande: Kürzer und einfacher – alle HTML-Knoten im DOM finden

Schleifen – z.B. while-Schleifen – können zum selben Ergebnis kommen wie Rekursive Funktionen. Der Vorteil der Rekursiven Funktionen liegt in der Lesbarkeit.

Rekursive anonyme Funktionen

Wer das Konzept der anonymen Funktionen mag, fragt sich jetzt natürlich sofort, ob und wie anonyme Funktion rekursiv aufgerufen werden, da sie ja keinen Namen haben.

In jeder Funktion existiert ein Arguments-Objekt, das neben der bekannten Eigenschaft length die selten benutzte Eigenschaft callee hat. callee gibt den Funktionskörper der aktuell ausgeführten Funktion zurück. Anonyme Funktionen verwenden die callee-Eigenschaft des Arguments-Objekts, um sich selber rekursiv aufzurufen.

Das Argument callee wurde allerdings aus dem ECMASCRIPT 5 Strict Mode entfernt.

<form action="rekursive-Funktionen.html" method="get" id="jsfuncCallee">
   <p><input type="text" name="mittel" id="mit0" /></p>
   <p><input type="submit" value="Mittel berechnen" /></p>
</form>

Das Formular berechnet den Mittelwert einer beliebigen Anzahl von Eingaben. Jedes Mal, wenn der Benutzer einen Wert in ein Feld eingibt, erzeugt die anonyme Funktion ein neues Feld für die nächste Zahl und registriert sich selbst als Event Handler für das neue Feld.

let wert = document.getElementById( 'mit0' );
wert.onfocus = function() {
   this.onfocus = null;
   let newInput = this.cloneNode();
   this.parentNode.appendChild(document.createElement( 'br' ));
   this.parentNode.appendChild( newInput );
   newInput.onfocus = arguments.callee;
};

Die erste Anweisung let wert = document.getElementById('mit0'); liest das Element mit der id mit0 ein – das ist das anfängliche Eingabefeld des Dokuments. Wenn das Feld in den Fokus kommt (beim Klick der Maus in das Feld oder bei einer Navigation mit der Tastatur) meldet this.onfocus = null; die Registrierung für das Ereignis ab, damit unentschlossene Benutzern nicht mit jedem Klick in ein Eingabefeld unzählige Eingabefelder erzeugen.

Die nächste Anweisung clont ein neues Eingabefeld und fügt on the fly ein BR- und direkt danach das neu erzeugte INPUT-Element in das Formular ein. Die Rekursion sitzt in der letzten Zeile der anonymen Funktion: newInput.onfocus = arguments.callee;. Die anonyme Funktion registriert sich selbst als Event Handler, wenn das neue Eingabefeld in den Fokus kommt, denn arguments.callee enthält genau die anonyme Funktion.

REKURSIVE Funktionen