Anonyme Funktion

Funktionsdefinition der kein Name zugeordnet wurde

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. Eine anonyme Funktion, die Zugriff auf ihren Erstellungskontext erhält, wird Closure genannt.

Benannte FunktionenBearbeiten

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 FunktionenBearbeiten

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.

BeispieleBearbeiten

Common LispBearbeiten

(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!")

PerlBearbeiten

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.

DBearbeiten

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

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

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

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

int main() {
    auto closure = []() { std::cout << "hello" << std::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.

Weitere SprachenBearbeiten

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.

EinzelnachweiseBearbeiten

  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). openbook.galileocomputing.de (Memento des Originals vom 16. Juli 2012 im Internet Archive)  Info: Der Archivlink wurde automatisch eingesetzt und noch nicht geprüft. Bitte prüfe Original- und Archivlink gemäß Anleitung und entferne dann diesen Hinweis.@1@2Vorlage:Webachiv/IABot/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.

WeblinksBearbeiten