CSS, HTML und Javascript mit {stil}

Rekursive Funktionen in Javascript

Rekursion: Sierpinsky triangle, von Sierpinsky

Rekursionen wiederholen Anweisungen in einer immer wieder gleichen Art und Weise. In der Programmierung nennt man Funktion, die sich selbst innerhalb des Funktionskörpers aufrufen, rekursive Funktionen. Berühmte Beispiele sind die Berechnung von Fibonacci-Zahlen und das Durchlaufen von Baumstrukturen.

Wie lang oder wie oft die Rekursion durchgeführt wird, muss innerhalb des Funktionskörpers gesteuert werden: Damit die Rekursion endet, darf sie irgentwann nicht erneut aufgerufen werden. Ansonsten kommt die große unendliche Schleife …

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?«.

Fakultät zur Berechnung von Permuationen
function fakultaet (n) {
    if ( n == 0 || n == 1 ) {
    	console.log ('Und das wars!')
        return 1;
    }
    
    var result = n; 
    while ( n > 1 ) {
    	console.log ('n = ' + n + ' | Result = ' + result );
        result = result * ( n - 1 );
        n = n - 1;
    }
    return result;
}

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

Mit Hilfe der Ausgabe in der Console des Browsers lässt sich die Rekursion nachvollziehen.

Rekursive Funktionen – Konsolen-Ausgabe
var fakultaet = function computeFactorial (number) {
   if (number <= 1) {
      return 1;
   }
   return number * computeFactorial (number - 1 );
}

var result = fakultaet (5);
console.log ('Result ' + result);

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 selber auf.

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.

var 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!

Rekursiv durch das DOM

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;
   var allTags = new Array();
   var result = document.getElementById('result');
   
   function countTags(obj) {
      var elems = obj.childNodes;
      countTags.counter++;
      for (var 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.

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.

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

Die erste Anweisung var 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.