imported>Redeemer: +link

2025-10-20T20:12:43Z

+link

Neue Seite

Eine '''anonyme Funktion''' (auch '''Funktionsliteral''', '''Lambda-Funktion''' oder '''Lambda-Ausdruck''') ist eine [[Funktion (Programmierung)|Funktionsdefinition]], die nicht an einen Bezeichner gebunden ist. Anonyme Funktionen werden häufig als Argumente an [[Funktion höherer Ordnung|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 [[Funktionale Programmierung|funktionalen Programmiersprachen]] und anderen Sprachen mit [[First-Class-Funktion|First-Class-Funktionen]] allgegenwärtig, wo sie für den Funktionstyp dieselbe Rolle erfüllen wie Literale für andere [[Datentyp|Datentypen]].

Anonyme Funktionen wurden ursprünglich von [[Alonzo Church]] mit seiner Erfindung des [[Lambda-Kalkül|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 [[Programmiersprache|Programmiersprachen]], und eine wachsende Anzahl moderner Programmiersprachen unterstützt anonyme Funktionen.

== Benannte Funktionen ==

Im Gegensatz zu einer anonymen Funktion erhält eine benannte Funktionen bei ihrer [[Deklaration (Programmierung)|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]]'''

<syntaxhighlight lang="javascript">
function Bezeichner_meiner_Funktion() {
console.log("Hallo, Welt!");
}

Bezeichner_meiner_Funktion();
</syntaxhighlight>

== Beispiele ==

=== Common Lisp ===

Die folgende Funktion verdoppelt ihr Argument:

<syntaxhighlight lang="common-lisp">
(lambda (x) (* x 2))
</syntaxhighlight>

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

<syntaxhighlight lang="common-lisp">
(funcall (lambda (x) (* x 2)) 5)
</syntaxhighlight>

Der Wert dieses Ausdrucks ist <code>10</code>.

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

<syntaxhighlight lang="common-lisp">
(defun meinFilter (eigenschaft liste)
(cond ((null liste) nil)
((if (funcall eigenschaft (car liste))
(cons (car liste) (meinFilter eigenschaft (cdr liste)))
(meinFilter eigenschaft (cdr liste))))))

(print
(meinFilter
(lambda (wert) (= (mod wert 2) 0))
'(0 1 2 3 4 5 6 7 8 9)))
</syntaxhighlight>
Das Ergebnis der Berechnung ist <syntaxhighlight lang="common-lisp"> (0 2 4 6 8) </syntaxhighlight>

=== C++ ===

Lambda-Ausdrücke bieten semantisch ähnliche Möglichkeiten wie das verwandte Konzept der [[Zeiger (Informatik)#Funktionszeiger (Methodenzeiger)|Funktionszeiger]]. In C++ können anonyme Funktionen folgendermaßen definiert werden:

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

* 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

<syntaxhighlight lang="cpp">
#include <functional>
#include <iostream>
#include <vector>

using namespace std;

vector<int> meinFilter(function<bool(int)> eigenschaft, const vector<int> &liste) {
auto sieb = vector<int>();
sieb.reserve(liste.size());

for (int element: liste)
if (eigenschaft(element))
sieb.push_back(element);

return sieb;
}

int main() {
vector<int> liste = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
auto sieb = meinFilter([](int wert) { return wert % 2 == 0; }, liste);

for (int element: sieb)
cout << element << " ";

return 0;
}
</syntaxhighlight>

=== C# ===

<syntaxhighlight lang="c#">
using System;
using System.Collections.Generic;

delegate bool Funktion(int wert);

class Programm {
static List<int> meinFilter(Funktion eigenschaft, List<int> liste) {
var sieb = new List<int>();
sieb.Capacity = liste.Count;

foreach (var element in liste)
if (eigenschaft(element))
sieb.Add(element);

return sieb;
}

public static void Main(string[] args) {
var liste = new List<int>() {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
var sieb = meinFilter(wert => wert % 2 == 0, liste);

foreach (int element in sieb)
Console.Write(element + " ");
}
}
</syntaxhighlight>

=== Haskell ===

<syntaxhighlight lang="haskell">
meinFilter eigenschaft liste = [element | element <- liste, eigenschaft element]

main = print $ meinFilter (\wert -> mod wert 2 == 0) [0..9]
</syntaxhighlight>

=== Java ===

In Java mussten für diesen Zweck früher ''anonyme innere [[Klasse (Objektorientierung)|Klassen]]''<ref name="Java Insel 9, 8.1.4"/> verwendet werden. Ab Version 8 stehen sogenannte ''[[Lambda-Ausdruck (Java)|Lambda-Ausdrücke]]'' zur Verfügung.<ref name="EffectiveJava 8"/>

<syntaxhighlight lang="java">
import java.util.ArrayList;
import java.util.Arrays;
import java.util.function.IntPredicate;
import java.util.List;

class Main {
static List<Integer> meinFilter(IntPredicate eigenschaft, List<Integer> liste) {
var sieb = new ArrayList<Integer>();

for (Integer element: liste)
if (eigenschaft.test(element))
sieb.add(element);

return sieb;
}

public static void main(String[] args) {
var liste = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
var sieb = meinFilter(wert -> wert % 2 == 0, liste);

for (var element: sieb)
System.out.print(element + " ");
}
}
</syntaxhighlight>

=== JavaScript ===

<syntaxhighlight lang="javascript">
function meinFilter(eigenschaft, liste) {
let sieb = [];

for (let element of liste)
if (eigenschaft(element))
sieb.push(element);

return sieb;
}

let liste = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
console.log(meinFilter(wert => wert % 2 == 0, liste));
</syntaxhighlight>

=== Python ===

<syntaxhighlight lang="python3">
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))
</syntaxhighlight>

== Einzelnachweise ==

<references>
<ref name="Java Insel 9, 8.1.4">{{Literatur
|Autor=Christian Ullenboom
|Titel=Java ist auch eine Insel
|Auflage=13., aktualisierte
|Verlag=Galileo Press
|Ort=Bonn
|Datum=2017
|ISBN=978-3-8362-5869-2
|Kapitel=8.5 Anonyme innere Klassen
|Online=[https://openbook.rheinwerk-verlag.de/javainsel/08_005.html#u8.5 openbook.galileocomputing.de]
}}
</ref>
<ref name="EffectiveJava 8">{{Internetquelle
|autor=Angelika Langer
|url=https://www.angelikalanger.com/Articles/EffectiveJava/71.Java8.Lambdas/71.Java8.Lambdas.html
|titel=Lambda-Ausdrücke und Methoden-Referenzen
|werk=
|hrsg=
|datum=2013-11
|abruf=2020-04-17}}
</ref>
</references>

[[Kategorie:Compilerbau]]
[[Kategorie:Programmiersprachelement]]

Anonyme Funktion - Versionsgeschichte

imported>Redeemer: +link