Anonyme Funktion

aus Wikipedia, der freien Enzyklopädie
Zur Navigation springen Zur Suche springen

Eine anonyme Funktion oder Lambda-Funktion ist eine Funktion in einem Computerprogramm, die nicht über ihren Namen, sondern nur über Verweise wie Referenzen oder Zeiger angesprochen werden kann.

Benannte Funktionen[Bearbeiten | Quelltext bearbeiten]

Eine benannte Funktion erhält bei ihrer Deklaration einen eindeutigen Namen, unter dem sie anschließend angesprochen wird.

Beispiel in Perl

sub identifier {
    return 0;
}

identifier();

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 C++ bzw. C

int identifier() {
    return 0;
}

identifier();

Anonyme Funktionen[Bearbeiten | Quelltext bearbeiten]

Mit dem Konzept anonymer Funktionen ist es möglich, neben benannten auch unbenannte Funktionen zu definieren. Unbenannte Funktionen werden häufig auch anonyme Funktionen oder, nach dem Lambda-Kalkül, gelegentlich auch Lambdas oder Lambda-Funktionen genannt.

Beispiele[Bearbeiten | Quelltext bearbeiten]

Common Lisp[Bearbeiten | Quelltext bearbeiten]

(lambda (x) (* x 2))

Um diese Funktion, die einen Wert verdoppelt, im selben Zug zu verwenden, kann sie in Funktionsposition direkt auf das beispielhafte Argument 5 angewendet werden:

((lambda (x) (* x 2)) 5)

Worauf das Lisp-System mit 10 antwortet. Danach wird die Funktionsdefinition, da sie nicht an ein Symbol gebunden ist, durch Garbage Collection gelöscht.

Python

closure = lambda: print("hello")
closure()

def write_message(receive_message):
    print(receive_message())

write_message(lambda: "world!")

Perl[Bearbeiten | Quelltext bearbeiten]

Die anonyme Funktion wird nach Deklaration und Definition an eine Referenz-Variable zugewiesen.

my $closure = sub { print "hello\n"; };
$closure->();

sub write_message {
    my $receive_message = $_[0];
    print $receive_message->();
}

write_message(sub { return "world!\n"; });

Da die Funktion hierbei keinen Namen hat, ist ein symbolischer Aufruf nicht mehr möglich. Sie wird vielmehr über eine Referenz, einen Verweis auf die Definition indirekt angesprochen.

D[Bearbeiten | Quelltext bearbeiten]

import std.stdio;

void write_message(string function() receive_message) {
    writeln(receive_message());
}

void main() {
    auto closure = () => writeln("hello");
    closure();
    
    write_message(() => "world!");
}

Anonyme Funktionen können die Programmierung kontextabhängiger Funktionsaufrufe sehr stark vereinfachen. Darüber hinaus ermöglichen sie die einfache Verwendung von Funktionsreferenzen als Funktionsargumente, beispielsweise zur Übergabe einer Rückruffunktion (callback), und die Speicherung in Datenstrukturen.

C++[Bearbeiten | Quelltext bearbeiten]

In C++ können anonyme Funktionen folgendermaßen definiert werden:

[capture] (parameter) -> type { body }
[capture] (parameter) { body }
[capture] { body }
  • capture: Übertrag der angegebenen Symbole in den Gültigkeitsbereich des Lambda-Ausdrucks
  • parameter: Liste der Übergabeparameter
  • type: Rückgabetyp
  • body: Funktionsrumpf
#include <functional>
#include <iostream>
#include <string>

using namespace std;

void write_message(function<string()> receive_message) {
    cout << receive_message() << endl;
}

int main() {
    auto closure = []() { cout << "hello" << endl; };
    closure();
    
    write_message([]() { return "world!"; });
}

Das verwandte Konzept der Funktionszeiger in den Programmiersprachen C und C++ bietet ähnliche Möglichkeiten, ist aber aufgrund seiner Syntax nicht trivial in der Anwendung. Zudem bleibt dort die eigentliche Funktion gleich benannt, separat definierte Verweise darauf können aber beliebige Namen tragen.

In C++ können Funktionszeiger durch Lambda-Ausdrücke ersetzt werden, die, wie in den Beispielen gezeigt, ähnlich wie in Perl oder anderen Sprachen genutzt werden können.

In Java können für diesen Zweck anonyme innere Klassen[1] und ab Version 8 Closures[2] verwendet werden.

Anonyme Funktionen werden von den meisten Skriptsprachen unterstützt, beispielsweise von Perl, Python, Lisp und – in neueren Versionen – von JavaScript und JScript.

Einzelnachweise[Bearbeiten | Quelltext bearbeiten]

  1. Christian Ullenboom: Java ist auch eine Insel. 10., aktualisierte Auflage. Galileo Press, Bonn 2012, ISBN 978-3-8362-1802-3, 7.5 Anonyme innere Klassen (openbook.galileocomputing.de).
  2. (hs): Project Lambda: So werden Closures in Java 8 aussehen. In: JAXenter. it republik, 9. September 2011, abgerufen am 19. September 2011.

Weblinks[Bearbeiten | Quelltext bearbeiten]