JavaScript – Anonyme Funktionen

Javascript anonyme Funktionen verstecken ihre Variablen

Anonyme Funktionen sind Funktionen ohne Namen, die sofort ausgeführt werden. Wenn Funktionen sehr einfach sind, verbessern eine anonyme Funktion die Lesbarkeit. Anonyme Funktionen halten den Code besser zusammen und erzeugen einen abgeschirmten Gültigkeitsbereich, ihren Scope.

23-02-02 SITEMAP CSS HTML JS Basis JS Web Tutorial SVG

Schutz vor doppelten Variablennamen

Die Deklaration von Variablen mit dem Schlüsselwort var außerhalb von Funktionen erhebt die Variable ohne Rücksicht und Skrupel in das globale Objekt. Ein weiteres Skript, das denselben Variablennamen benutzt, überschreibt die erste Variable und schon versinken wir in einer Fehlerquelle.

Variablen, die in Funktionen definiert werden, leben hingegen in ihrem eigenen abgeschirmten Raum. Vor dem Auftritt von let und const waren anonyme Funktionen der einfachste Schutz vor doppelten Variablennamen und versehentlichem Überschreiben.

Funktions-Deklarationen

ECMAScript gibt ein ganzes Spektrum von Techniken für die Definition von Funktionen vor:

Deklaration
function sum(a, b) {
    return a + b;
}
Anonyme Funktion oder Funktions-Ausdruck
let sum = function(a, b) { 
   return a + b; 
}
Selbst-aufrufende Funktion
(function(a, b) { 
   return a + b; 
})();
Arrow Function
var absValue = (number) => {  
  if (number < 0) {
    return -number;
  }
  return number;
}
console.log (absValue(-10)); // 10
console.log (absValue(5));   // 5
Konstruktor-Methode
const sum = new Function('a','b', 'return a + b');
console.log ( "sum " + sum(10, 20) );

Anonyme Funktion oder Funktions-Ausdruck

Eine anonyme Funktion hat Zugriff auf jede Variable, die bei der Definition der Funktion sichtbar war, einschließlich lokaler Variablen. Das macht anonyme Funktionen so schön einfach.

Während eine Funktion meist einige Zeilen weiter oben deklariert wird und erst durch den Aufruf ausgeführt wird, wertet Javascript anonyme Funktionen direkt an Ort und Stelle aus.

const summe  = 500; 
const betrag = 20;
const satz   = 19;
//console.log('summe ' + summe);
const mytwocents = function (betrag, satz) {
   const mwst = betrag * satz / 100;
   const summe = betrag + mwst;
   return summe;
}

console.log (`mytwocents ${mytwocents(20,19)} – Summe ${summe}`);
[Log] mytwocents 23.8 – Summe 500 

Anonyme Funktionen ersetzen den Funktionsaufruf, werden aber ansonsten genauso notiert wie normale Funktionen: Zwischen der öffnenden und schliessenden geschweiften Klammer stehen dieselben Anweisungen, die auch in der normalen Funktion gestanden hätten. Da sie innere Funktionen sind, gewähren sie Anweisungen außerhalb der Funktion, in der sie liegen, keinen Zugriff. Variablen innerhalb der Funktion können nicht von außen überschrieben werden.

In der Verarbeitung von Events werden häufig anonyme Funktionen verwendet:

document.getElementById('foo').onclick = function () {
}

Anonyme Funktionen als Parameter von Funktionen kennen wir ebenfalls von den Event Handlern addEventListener.

window.addEventListener ("click", function () {
});

Es geht sogar ohne Zuweisung:

(function () {
	const autor = 'Pratchett';
	const titel  = 'Schöne Scheine';
	const buch = [autor, titel];
	console.log (`Buch ${buch.join(",")}`);
})();

Diese Schreibweise erzeugt eine literale Funktion, der kein Name zuwiesen wird. Die umfassenden runden Klammern führen dazu, dass die Funktion sofort ausgeführt wird – so als würde die Funktion an dieser Stelle aufgerufen. Darum spricht man auch von selbst ausführenden Funktionen (besser wäre die Bezeichnung »sofort ausgeführte Funktion«).

Bei der Ausführung erzeugt die Funktion drei Variablen, formatiert sie und gibt sie aus. Sobald die Funktion abgearbeitet ist, werden die Variablen vernichtet und das globale Objekt bleibt unverändert.

Mit Hilfe von anonymen Funktionen schützt sich das Script vor Überschneidungen und Kollision mit anderen Scripten. Aus diesem Grund gehören anonyme und sich selbst ausführende Funktionen heute zu den wichtigen Konventionen der professionellen Programmentwicklung.

Nachteile anonymer Funktionen

  • Testen und debuggen von anonymen Funktionen ist nicht einfach,
  • sie können nicht mehrfach verwendet werden,
  • ohne Namen geben anonyme Funktionen auf dem ersten Blick keine Beschreibung ihrer Aufgabe,
  • Strukturverlust, der Code kann aufgemischt wirken.