Anonyme Funktion

Eine anonyme Funktion (Funktionsliteral, Lambdafunktion oder Lambdaausdruck) ist eine Funktionsdefinition, die nicht an einen Bezeichner gebunden ist. Anonyme Funktionen werden häufig als Argumente an Funktionen höherer Ordnung übergeben oder zum Erstellen des Ergebnisses einer Funktion höherer Ordnung verwendet, die eine Funktion zurückgeben muss. Wenn eine Funktion nur an einer Stelle verwendet wird und einen begrenzten Umfang hat, kann eine anonyme Funktion syntaktisch einfacher sein als die Verwendung einer benannten Funktion. Anonyme Funktionen sind in funktionalen Programmiersprachen und anderen Sprachen mit First-Class-Funktionen allgegenwärtig, wo sie für den Funktionstyp dieselbe Rolle erfüllen wie Literale für andere Datentypen.

Anonyme Funktionen wurden ursprünglich von Alonzo Church mit seiner Erfindung des Lambda-Kalküls im Jahr 1936 geprägt, in dem alle Funktionen anonym sind. Anonyme Funktionen sind seit Lisp im Jahr 1958 ein Merkmal von Programmiersprachen, und eine wachsende Anzahl moderner Programmiersprachen unterstützt anonyme Funktionen.

Im Gegensatz zu einer anonymen Funktion erhält eine benannte Funktionen bei ihrer Deklaration einen eindeutigen Bezeichner, unter dem sie anschließend angesprochen wird. Der Name der Funktion wird vom Compiler oder vom Laufzeitsystem dazu verwendet, mit Hilfe der Symboltabelle oder eines dynamischen Verfahrens die Funktionsdefinition zu identifizieren und dort hinterlegten Code auszuführen.

Beispiel in JavaScript

functionBezeichner_meiner_Funktion(){
console.log("Hallo, Welt!");
}
Bezeichner_meiner_Funktion();

Die folgende Funktion verdoppelt ihr Argument:

(lambda(x)(*x2))

Um diese Funktion im selben Zug zu verwenden, kann die Funktion direkt auf ein Argument angewendet werden:

(funcall(lambda(x)(*x2))5)

Der Wert dieses Ausdrucks ist 10.

Das nächste Beispiel definiert eine Funktion höherer Ordnung und nennt sie meinFilter. Das erste Argument dieser Funktion ist eine weitere Funktion. Im unteren Teil des Beispiels wird für dieses Argument der lambda-Ausdruck angegeben.

(defunmeinFilter(eigenschaftliste)
(cond((nullliste)nil)
((if(funcalleigenschaft(carliste))
(cons(carliste)(meinFiltereigenschaft(cdrliste)))
(meinFiltereigenschaft(cdrliste))))))
(print
(meinFilter
(lambda(wert)(=(modwert2)0))
'(0123456789)))

Das Ergebnis der Berechnung ist

(02468)

Lambdaausdrücke bieten semantisch ähnliche Möglichkeiten wie das verwandte Konzept der Funktionszeiger. In C++ können anonyme Funktionen folgendermaßen definiert werden:

[capture]<template>(parameter) -> type { body }

• capture: Übertrag der angegebenen Symbole in den Gültigkeitsbereich des Lambda-Ausdrucks
• template: Liste der Templateparameter (ab C++20)
• parameter: Liste der Übergabeparameter
• type: Rückgabetyp
• body: Funktionsrumpf

#include<functional>
#include<iostream>
#include<vector>
usingnamespacestd;
vector<int>meinFilter(function<bool(int)>eigenschaft,constvector<int>&liste){
autosieb=vector<int>();
sieb.reserve(liste.size());
for(intelement:liste)
if(eigenschaft(element))
sieb.push_back(element);
returnsieb;
}
intmain(){
vector<int>liste={0,1,2,3,4,5,6,7,8,9};
autosieb=meinFilter([](intwert){returnwert%2==0;},liste);

for(intelement:sieb)
cout<<element<<" ";
return0;
}

usingSystem;
usingSystem.Collections.Generic;
delegateboolFunktion(intwert);
classProgramm{
staticList<int>meinFilter(Funktioneigenschaft,List<int>liste){
varsieb=newList<int>();
sieb.Capacity=liste.Count;
foreach(varelementinliste)
if(eigenschaft(element))
sieb.Add(element);
returnsieb;
}
publicstaticvoidMain(string[]args){
varliste=newList<int>(){0,1,2,3,4,5,6,7,8,9};
varsieb=meinFilter(wert=>wert%2==0,liste);
foreach(intelementinsieb)
Console.Write(element+" ");
}
}

meinFiltereigenschaftliste=[element|element<-liste,eigenschaftelement]
main=print$meinFilter(\wert->modwert2==0)[0..9]

In Java mussten für diesen Zweck früher anonyme innere Klassen ^[1] verwendet werden. Ab Version 8 stehen sogenannte Lambda-Ausdrücke zur Verfügung.^[2]

importjava.util.ArrayList;
importjava.util.Arrays;
importjava.util.function.IntPredicate;
importjava.util.List;
class Main{
staticList<Integer>meinFilter(IntPredicateeigenschaft,List<Integer>liste){
varsieb=newArrayList<Integer>();
for(Integerelement:liste)
if(eigenschaft.test(element))
sieb.add(element);
returnsieb;
}
publicstaticvoidmain(String[]args){
varliste=Arrays.asList(0,1,2,3,4,5,6,7,8,9);
varsieb=meinFilter(wert->wert%2==0,liste);
for(varelement:sieb)
System.out.print(element+" ");
}
}

functionmeinFilter(eigenschaft,liste){
letsieb=[];
for(letelementofliste)
if(eigenschaft(element))
sieb.push(element);
returnsieb;
}
letliste=[0,1,2,3,4,5,6,7,8,9];
console.log(meinFilter(wert=>wert%2==0,liste));

def meinFilter(eigenschaft, liste):
 sieb = []
 for element in liste:
 if eigenschaft(element):
 sieb.append(element)
 return sieb
liste = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(meinFilter(lambda wert: wert % 2 == 0, liste))

1. ↑ Christian Ullenboom: Java ist auch eine Insel. 13., aktualisierte Auflage. Galileo Press, Bonn 2017, ISBN 978-3-8362-5869-2, 8.5 Anonyme innere Klassen (openbook.galileocomputing.de). 
2. ↑ Angelika Langer: Lambda-Ausdrücke und Methoden-Referenzen. November 2013, abgerufen am 17. April 2020. 

• Compilerbau
• Programmiersprachelement