Quelltext der Seite Closure (Funktion)

Eine '''Closure''' ist ein Konzept aus der [[Funktionale Programmierung|funktionalen Programmierung]]. Wenn eine Funktion, die [[Freie Variable und gebundene Variable|freie Variablen]] verwendet, den [[Variable (Programmierung)#Sichtbarkeitsbereich von Variablen (Scope)|Scope]] verlässt, in dem diese vereinbart sind (meistens, weil sie selbst von einer Funktion zurückgegeben wird), und wird dieser Scope abgeräumt, so wären diese freien Variablen ab diesem Zeitpunkt undefiniert. Um dem zu begegnen, setzt der Compiler bei der Rückgabe eine neue Struktur zusammen. Sie besteht aus dieser Funktion und sämtlichen von ihr verwendeten freien Variablen. Diese Struktur heißt Closure.

Der Name deutet an, dass die betroffenen Variablenbindungen ab diesem Zeitpunkt nicht mehr von außerhalb der Closure erreicht werden können (Es gibt Ausnahmen, falls mehrere Closures gleichzeitig erzeugt werden, s.&nbsp;u.).

Die Closure wird von Laufzeitsystem und Compiler von reinen Funktionen unterschieden. Sie muss auch logisch von diesen unterschieden werden, da sie durch die in ihr enthaltenen (auch: „ge-closure-ten“) Variablenbindungen innere Zustände hat und darum in aufeinanderfolgenden Aufrufen unterschiedliche Werte für gleiche Argumente liefern kann.

Daher kann man eine Closure auch als Objekt ansehen, das in der Regel nur eine Methode hat. Wird die Closure zusammen mit weiteren Closures in demselben Kontext erzeugt, so handelt es sich um ein Objekt mit mehreren Methoden. Die in der Closure eingeschlossenen Variablen aus dem erzeugenden Bereich können von der Closure als Attribute verwendet werden.

== Herkunft ==
Closures sind ein Konzept, das aus den [[Funktionale Programmierung|funktionalen Programmiersprachen]] stammt, zum ersten Mal in [[Lisp]] auftrat und in seinem Dialekt [[Scheme]] erstmals vollständig unterstützt wurde. Daraufhin wurde es auch in den meisten späteren funktionalen Programmiersprachen (etwa [[Haskell (Programmiersprache)|Haskell]], [[Ocaml]]) unterstützt.

== Vorteile und Eigenschaften ==
Mit Closures können nicht sichtbare, aber kontrolliert veränderbare Bereiche erstellt werden, beispielsweise kann damit [[Datenkapselung (Programmierung)|Datenkapselung]] realisiert oder [[Currying]] umgesetzt werden.

Die Erzeugung einer Closure ist mit deutlich weniger Arbeit verbunden als die Erstellung einer Klasse mit nur einer Methode. Objektorientierter Sichtweise folgend eignen sich Closures so zur schnellen Erzeugung einer objektähnlichen Struktur ohne eine Klasse. Oftmals wird als innere Methode eine [[anonyme Funktion]] verwendet.

In einer rein funktionalen Programmiersprache kann eine Closure immer dann verwendet werden, wenn sie entweder selbst als Funktion aufgerufen oder als Parameter in einen Funktionsaufruf eingehen soll. Im letzteren Fall kann sie als zur Laufzeit erzeugte Call-Back-Funktion agieren und ermöglicht so einem Anwendungsprogramm in erheblichen Maß während seiner Laufzeit den eigenen Kontrollfluss zu manipulieren. Dies wird allerdings meistens erst durch ein System von Closures praktisch sinnvoll ermöglicht. Auf dieser Tatsache beruht das didaktische Problem, unerfahrenen Programmierern die Anwendung von Closures nahezubringen.

=== Beispiel in Pseudocode ===
Im folgenden Beispiel wird zunächst eine Funktion <code>mutterfunktion</code> definiert. Diese Funktion setzt eine lokale Variable namens <code>kuchentyp</code> und definiert eine lokale Funktion namens <code>kindfunktion</code>.

 '''funktion''' mutterfunktion {
     '''setze''' kuchentyp = 'Apfelkuchen'

     '''funktion''' kindfunktion {
         '''gib_aus''' 'Ich esse #{kuchentyp}'
     }

     '''gib_zurück''' kindfunktion
 }

Bei einem Aufruf gibt <code>mutterfunktion</code> die lokale Funktion <code>kindfunktion</code> (nicht deren Ergebnis!) zurück. (Dies ist in nicht funktionalen Programmiersprachen wie [[C (Programmiersprache)|C]] und Verwandten technisch auch als Funktionszeiger bekannt. Ein typisierter Funktionszeiger heißt [[Delegation (Softwareentwicklung)|Delegate]].)

 '''setze''' meinkuchen = '''rufe_auf''' mutterfunktion

Die globale Variable <code>meinkuchen</code> bekommt also die Funktion <code>kindfunktion</code> zugewiesen.

 '''rufe_auf''' meinkuchen

Beim anschließenden Aufruf von <code>meinkuchen</code> wird folglich <code>kindfunktion</code> ausgeführt. Obwohl keine globale Variable <code>kuchentyp</code> existiert, gibt <code>kindfunktion</code> die [[Zeichenkette]] <code>'Ich esse Apfelkuchen'</code> aus, weil sie auf ihren Erstellungskontext zugreifen kann, in dem die Variable <code>kuchentyp</code> mit <code>'Apfelkuchen'</code> definiert ist. Entscheidend ist dabei: Obwohl <code>mutterfunktion</code> schon einen Wert zurückgegeben hat – der Kontext also eigentlich nicht mehr existiert – kann <code>kindfunktion</code> darauf zugreifen – <code>kindfunktion</code> ist also eine Closure-Funktion.

 [Ausgabe:] Ich esse Apfelkuchen

Mit einer Änderung im Code wird nun der Wert der Variablen <code>anzahl_kuchen</code> in der <code>mutterfunktion</code> mit jedem Zugriff auf die Closure-Funktion um eins erhöht, womit sich ein Zähler realisieren lässt. Der Wert in <code>anzahl_kuchen</code> ist vor Manipulation geschützt und kann nur durch <code>essen</code> erhöht werden.

 '''funktion''' mutterfunktion {
     '''setze''' anzahl_kuchen = 0

     '''funktion''' kindfunktion {
         '''setze'''  anzahl_kuchen = anzahl_kuchen + 1
         '''gib_aus''' 'Ich esse #{anzahl_kuchen} Kuchen'
     }

     '''gib_zurück''' kindfunktion
 }

Mit mehrfachen Aufrufen der Mutterfunktion von anderen Programmteilen aus kann nur indirekt auf den eigentlich nicht mehr sichtbaren Wert der lokalen Variable <nowiki><anzahl_kuchen></nowiki> zugegriffen werden, und (nur) innerhalb der <code>kindfunktion</code> können (gekapselte) Berechnungen mit sonst nicht veränderbaren Werten vorgenommen werden – das zeigt die erwähnten Hauptvorteile von Closures:

 '''setze''' essen = '''rufe_auf''' mutterfunktion
 '''rufe_auf''' essen
 '''rufe_auf''' essen
 '''rufe_auf''' essen

 Ich esse 1 Kuchen
 Ich esse 2 Kuchen
 Ich esse 3 Kuchen

Der direkte Zugriff auf die Variable <code>anzahl_kuchen</code> ist so geschützt, ihr Wert kann (wie im Beispiel) oder könnte auch nicht direkt nach außen gereicht werden. Keinesfalls ist der Wert aber von außen veränderbar, damit bieten Closures mehr Zugriffsschutz als etwa als „private“ deklarierte Felder einer Klasse etwa in [[Java (Programmiersprache)|Java]] oder [[C-Sharp|C#]], der etwa mit [[Reflexion (Programmierung)|Reflection]] einfach zu umgehen ist.

Wie man dies interpretiert, hängt stark von der eigenen Sichtweise auf Programmiersprachen ab. Die Mutterfunktion übernimmt aus objektorientierter Sichtweise die Rolle einer Klasse, genauer eines Objekts (der Instanz einer Klasse) und kapselt aus objektorientierter Sicht so Kindvariablen mit Kindfunktion(en) zu einer Einheit.

Anders gesehen wird so eine Art aufrufübergreifendes „Gedächtnis“ in den Funktionen implementiert, ähnlich einer statischen Variablen, nur leistungsfähiger. Noch ein wenig anders betrachtet kann man dies auch als Veränderung des Kontrollfluss ansehen wie obiges Beispiel sehr gut zeigt. Aufzählungen können etwa als Funktionsaufruf implementiert werden, da bei jedem Aufruf (aufgrund des „Gedächtnisses“) ein anderes Ergebnis geliefert werden kann. C# nutzt dies als Spezialfall etwa bei der [[Implementierung]] von „yield return“. Dabei wird pro Aufruf Schritt für Schritt das nächste Element eines aufzählbaren Typs wie einer Liste, sozusagen [[Lazy Evaluation|„faul“ (lazy)]], d.&nbsp;h. ressourcensparend nur bei Bedarf zurückzugeben.<ref>{{Internetquelle |autor=Ted Neward |url=http://blogs.tedneward.com/patterns/closurebasedstate-csharp/ |titel=Closure-based State: C# |datum=2016-04-02 |sprache=en |offline=ja |archiv-url=https://web.archive.org/web/20220123034647/http://blogs.tedneward.com/patterns/closurebasedstate-csharp/ |archiv-datum=2022-01-23 |archiv-bot= |abruf=2022-04-14}}</ref>

== Konzeptionelle Voraussetzungen für Closures in Programmiersprachen ==

Closures stellen wie erwähnt ein Muster funktionaler Programmierung dar, sie sind für Programmierer nicht rein funktionaler Programmiersprachen oftmals schwer zu verstehen, auch wenn sie in zunehmend mehr Programmiersprachen umsetzbar sind.

Folgende konzeptionelle „Bausteine“ sind nötig, um eine Closure in einer Programmiersprache umsetzbar zu machen.

1. Funktionen müssen als Rückgabeobjekte einer anderen Funktion erlaubt sein, mindestens über zu Hilfe genommene Elemente wie [[Funktionszeiger]], Delegates oder Lambda-Ausdrücke. Man spricht hier auch von [[First-Class-Funktion]]en. (Das Gegenteil ist insbesondere der Fall, wenn Funktionen lediglich als eine Art benannter Befehl betrachtet und verwendet werden können).

2. In obigem Beispiel muss die innere Funktion auf die Variablen der äußeren Funktion (Aufrufumgebung) zugreifen können. Diese Variablen werden im Unterschied zu lokalen Variablen aus Sicht der inneren Funktion auch als „freie Variablen“ (englisch „free variables“) bezeichnet.

3. Der [[Compiler]] muss in der Lage sein, zu erkennen, dass der Wert (Zustand) der Variablen außerhalb deren eigentlichen Gültigkeitsbereich (scope) benötigt wird, und dies bei der Kompilierung aktiv berücksichtigen. Technisch werden diese Variablen dann meist nicht mehr auf dem Stack abgelegt, sondern dies wird anders gelöst, z.&nbsp;B. indem tatsächlich im Hintergrund eine (anonyme) Klasse samt Instanz erzeugt wird, die die benötigten (Member)variablen und die innere Funktion (als Memberfunktion) enthält.

Jetzt erst sind alle Bausteine beisammen, um eine verkürzte aber technischere Definition des Begriffes '''Closure''' aufzustellen, genau genommen von lexikalischen Closures im engeren Sinne:

Closures sind also eine Programmiertechnik bzw. Strukturen, um lexikalische [[Variable (Programmierung)#Sichtbarkeitsbereich von Variablen (Scope)|Skopierung (englisch scope)]] mit freien Variablen in Sprachen mit [[First-Class-Funktion]]en umzusetzen.

=== Dynamische und lexikalische Closures ===
Die erste Implementierung von Closures ergab sich aus der Art der Implementierung von Ausführungsumgebungen in Lisp. In den ersten Lisp-Implementierungen gab es keine [[Variable (Programmierung)#Variablen in einer Blockstruktur|lexikalische Skopierung]]. Die Ausführungsumgebung einer Anweisung bestand aus einer sogenannten [[A-Liste]] mit Variablenbindungen, die über eine einzelne Referenz erreichbar war. Eine Closure über einer Funktion bestand dann aus einem Paar, bestehend aus der Funktionsdefinition und der Referenz auf die zur Definitionszeit der Closure gültigen A-Liste. Dieses durch die Lisp-Funktion FUNCTION erzeugte Paar ist eine dynamische Closure mit der historischen Bezeichnung FUNARG (FUNctional ARGument). Gelangte das FUNARG später zur Ausführung, so geschah dies im Kontext der mitgebrachten A-Liste anstatt im Kontext der aktuell gültigen A-Liste.<ref>John McCarthy u.&nbsp;a.: [http://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf ''Lisp 1.5 Programmers Manual''.] (PDF; 4,5&nbsp;MB) softwarepreservation.org; abgerufen am 12. März 2014.</ref>

Die heute in Lisp wie in allen anderen Sprachen verwendete lexikalische Skopierung führt zur lexikalischen Closure, die auch in kompilierten Sprachen funktionsfähig ist. Sie entsteht erst durch aktives Eingreifen des Compilers, indem dieser die Bezüge der Funktion auf die innerhalb ihrer selbst freien und außerhalb von ihr gebundenen Variablen identifiziert und Code erzeugt, der diese Bindungen mit der Funktion zusammen bei ihrer Rückgabe aus ihrem Definitionskontext zu einer Closure zusammensetzt. Dies geschieht, bevor diese Funktion –&nbsp;nun als Closure&nbsp;– dem Aufrufer zur Verfügung gestellt wird. Da diese Variablenbindung nun nicht mehr lexikalisch gebunden ist, kann sie nicht auf dem Stack verbleiben, sondern wird vom Laufzeitsystem auf den Heap gelegt. Bei gleichzeitiger Bildung mehrerer Closures über derselben Variablenbindung sorgt das Laufzeitsystem dafür, dass in beide Closures dieselbe Heap-basierte Kopie dieser Variablenbindung eingesetzt wird.

== Implementierungen ==
Es existieren auch nicht-funktionale Programmiersprachen, die diese Funktion unterstützen. Dazu gehören [[Ada (Programmiersprache)|Ada]],<ref>John Barnes: [https://www.adaic.org/resources/add_content/standards/05rat/html/Rat-3-4.html Rationale for Ada 2005]</ref> [[C++]] (ab C++11), [[C-Sharp|C#]], [[Go (Programmiersprache)|Go]], [[Groovy]], [[Java (Programmiersprache)|Java]],<ref>[https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html Closures in Java]</ref> [[JavaScript]],<ref>[http://www.jibbering.com/faq/notes/closures/ Closures in JavaScript] (englisch)</ref> [[Lua]], [[Object Pascal]] (Delphi),<ref>{{Internetquelle |autor=Craig Stuntz |url=https://community.embarcadero.com/blogs/entry/understanding-anonymous-methods-37828 |titel=Understanding Anonymous Methods |werk=community.embarcadero.com |datum=2008-08-04 |sprache=en |abruf=2022-04-14}}</ref><ref>Barry Kelly: [http://barrkel.blogspot.com/2008/08/tiburon-fun-with-generics-and-anonymous.html ''Tiburon: fun with generics and anonymous methods''.]</ref> [[PHP]], [[Perl (Programmiersprache)|Perl]], [[Python (Programmiersprache)|Python]], [[Ruby (Programmiersprache)|Ruby]], [[Smalltalk (Programmiersprache)|Smalltalk]], [[Swift (Programmiersprache)|Swift]] und [[Visual Basic .NET]]. Apple hat den [[GNU Compiler Collection|gcc]] und [[Clang]] um Closures –&nbsp;genannt Block-Literals&nbsp;– für C erweitert und dies zur Standardisierung vorgeschlagen.<ref>[https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1370.pdf N1370: Apple’s Extensions to C] (PDF; 69&nbsp;kB)</ref>

== Beispiele von Implementierungen ==

=== Common Lisp ===
Dieses Beispiel verwendet eine Closure, um eine elegante Datenbankabfrage zu ermöglichen. Die Closure wird von der Funktion <code>name-is</code> geliefert. Durch die ''special function'' <code>lambda</code> wird eine namenlose Funktion erzeugt, innerhalb derer der Wert des Feldes ''name'' auf die Gleichheit mit einer Zeichenkette <code>n</code>geprüft wird. Der Aufruf <code>(name-is  "Elke")</code> liefert also eine Closure als Verbindung aus der anonymen Funktion und der Variablenbindung von <code>n</code> an die Zeichenkette „Elke“. Diese kann einen Datensatz auf den Namensgleichheit mit „Elke“ überprüfen. Die Closure kann direkt an die Funktion <code>filter</code> übergeben werden, die diese dann anwendet und das Ergebnis zurückgibt.

<syntaxhighlight lang="lisp">
(defparameter *dbase*
    '(("Elke"  "1.1.1980") ("Gabi"  "2.3.1981") ("Heidi" "4.5.1982")
      ("Gabi"  "5.6.1983") ("Uschi" "7.8.1984")))

(defun get-name (record)
    (first record))

(defun name-is (name)
    (lambda (record)
        (equal (get-name record) name)))

(defun filter (predicate list)
    (remove-if-not predicate list))
</syntaxhighlight>

Diese Definitionen machen nun folgende elegante Abfrage möglich:

<syntaxhighlight lang="lisp">
(print (filter (name-is "Gabi") *dbase*))
</syntaxhighlight>
Sie ist folgendermaßen zu verstehen: Der Funktionsaufruf <code>(name-is "Gabi")</code> liefert eine Closure. Sie ist hier eine Verbindung aus dem Vergleichscode <code>(equal (get-name record) name)</code> aus der Funktion <code>name-is</code> und der Bindung der Zeichenkette <code>"Gabi"</code> an die Variable <code>name</code>. Damit handelt es sich semantisch um die Abfrage <code>(equal (get-name record) "Gabi")</code>. Dieser Vergleich wird als Closure an die Funktion <code>filter</code> übergeben, die diesen Vergleich anwendet. Ausführen dieser Filterung führt dann zu dem Ergebnis:
<syntaxhighlight lang="lisp">
(("Gabi" "2.3.1981") ("Gabi" "5.6.1983"))
</syntaxhighlight>

=== Perl ===
Der Kontext eines beliebigen Code-Fragments wird unter anderem durch die zur Verfügung stehenden Symbole bestimmt:

<syntaxhighlight lang="perl">
# pragma
use strict;

sub function {
    # Argumente in benannte Variablen kopieren
    my ($var1, $var2) = @_;

    # block code
}
</syntaxhighlight>

Im oben gezeigten Beispiel sind die Variablen <code>$var1</code> und <code>$var2</code> an jeder Stelle der Funktion gültig und sichtbar. Beim Verlassen der Funktion werden sie zusammen mit dem verlassenen Block aufgeräumt („gehen“ ''out of scope'') und sind anschließend unbekannt. Jeder weitere Zugriff wäre ein Fehler.

''Closures'' bieten nun die Möglichkeit, den Gültigkeitsbereich solcher Variablen über dessen offizielles Ende hinaus auszudehnen. Dazu wird im Scope einfach eine Funktion definiert, die die betreffenden Variablen verwendet:

<syntaxhighlight lang="perl">
# pragma
use strict;

sub function {
    my ($var1, $var2) = @_;
    return sub { print "Vars: $var1, $var2.\n" };
}

my $f = function("Hallo", 8);
my $g = function("bar", "Y");

# Aufruf von $f
$f->();

# Aufruf von $g
$g->();
</syntaxhighlight>

Das Laufzeitsystem stellt jetzt beim Verlassen der Funktion <code>function</code> fest, dass noch Referenzen auf die Blockvariablen <code>$var1</code> und <code>$var2</code> bestehen – der Rückgabewert ist eine [[anonyme Subroutine]], die ihrerseits Verweise auf die Blockvariablen enthält. <code>$var1</code> und <code>$var2</code> bleiben deshalb mit ihren aktuellen Werten erhalten. Weil die Funktion auf diese Weise die Variablen konserviert, wird sie zur Closure.

Mit anderen Worten kann man auch nach dem Verlassen des eigentlichen Gültigkeitsbereichs der Variablen jederzeit den Aufruf <code>$f->()</code> und den Aufruf <code>$g->()</code> ausführen und wird im Ergebnis immer wieder die bei der Definition der Funktionen gültigen Werte der Variablen angezeigt bekommen.

Dies ergibt die Ausgabe:
 Vars: Hallo, 8.
 Vars: bar, Y.

Ändern kann man diese Werte nicht mehr, da die Variablen außerhalb der Closure nicht mehr verfügbar sind. Das liegt aber vor allem an der Funktionsdefinition: Natürlich hätte die Closure die Werte nicht nur ausgeben, sondern auch bearbeiten oder auch aufrufendem Code wieder per Referenz zur Verfügung stellen können. In der folgenden Variante werden beispielsweise Funktionen zum Inkrementieren und Dekrementieren eingeführt:

<syntaxhighlight lang="perl">
# pragma
use strict;

# function
sub function {
    my ($var1, $var2) = @_;

    return (
        sub {print "Vars: $var1, $var2.\n"},
        sub {$var1++; $var2++;},
        sub {$var1--; $var2--;}
    );
}

# call the function
my ($printer, $incrementor, $decrementor) = function(3,5);
# use closures
$printer->();
$incrementor->();
$printer->();
$incrementor->();
$incrementor->();
$printer->();
</syntaxhighlight>

Dies ergibt die Ausgabe:
 Vars: 3, 5.
 Vars: 4, 6.
 Vars: 6, 8.

Closures lassen sich also beispielsweise dazu verwenden, um den Zugriff auf sensible Daten zu kapseln.

=== Python ===
Folgend ein einfaches Beispiel für einen Zähler in Python, der ohne einen (benannten) Container auskommt, der den aktuellen Zählerstand speichert.
<syntaxhighlight lang="python">
def closure():
    container = [0]

    def inc():
        container[0] += 1

    def get():
        return container[0]

    return inc, get
</syntaxhighlight>

Im Beispiel werden innerhalb der <code>closure</code>-Funktion zwei Funktionsobjekte erstellt, die beide die Liste <code>container</code> aus ihrem jeweils übergeordneten Scope referenzieren. Ist die <code>closure</code>-Funktion also abgearbeitet (nach einem Aufruf) und werden die beiden zurückgegebenen Funktionsobjekte weiter referenziert, dann existiert die <code>container</code>-Liste weiter, obwohl der Closure-Scope bereits verlassen wurde. Auf diese Weise wird also die Liste in einem anonymen Scope konserviert. Man kann nicht direkt auf die Liste <code>container</code> zugreifen. Werden die beiden Funktionsobjekte <code>inc</code> und <code>get</code> nicht mehr referenziert, verschwindet auch der Container.

Die Closure im vorigen Beispiel wird dann auf die folgende Weise verwendet:

 >>> i, g = closure()
 >>> g()
 0
 >>> i()
 >>> i()
 >>> g()
 2

=== OCaml ===
[[OCaml]] erlaubt das in folgender Weise:
<syntaxhighlight lang="ocaml">
let counter, inc, reset =
    let n = ref 0 in
        (function () -> !n),    	 (* counter  *)
        (function () -> n:= !n + 1), (* incrementor *)
        (function () -> n:=0 )     	 (* reset  *)
</syntaxhighlight>
jetzt ist der Zähler wie folgt anwendbar:
<syntaxhighlight lang="OCaml">
# counter();; (* ergibt 0 *)
# inc();;
# counter();; (* ergibt 1 *)
# inc();inc();inc();;
# counter();; (* ergibt 4 *)
# reset();;
# counter();; (* ergibt 0 *)
# n;; (* n ist gekapselt *)
Unbound value n
</syntaxhighlight>

Statt einer Ganzzahl („Integer“) können natürlich auf diese Weise beliebige Objekte oder Variablen beliebiger Typen gekapselt werden.

=== JavaScript ===
In der Funktion f1 wird eine weitere Funktion f2 als Closure definiert;
<syntaxhighlight lang="javascript">
let f1 = function() {      // eine äußere Funktion f1 definieren ...
    let wert = 22;          // ... und darin einen Namensraum erstellen.

    let f2 = function() {  // eine innere Funktion definieren, ...
        return wert;          // ... die den Namensraum nach außen reicht.
    }

    return f2;   // f2 durch f1 zurückgeben, womit f2 zum closure wird.
}

let a = f1(); // a ist die von f1() zurückgegebene closure-Funktion, ...
console.log(f1()); // ... also: function() {return wert;}
console.log(typeof wert); // ist undefined
console.log(a()); // ergibt 22
console.log(f1()()); // ergibt 22, f2() ist hier aber nicht abrufbar
</syntaxhighlight>

Obiges Beispiel etwas anders formuliert, die innere Funktion wird jetzt direkt aufgerufen:
<syntaxhighlight lang="javascript">
let f3 = function() {
    let wert = 23;

    // die Funktion f3 gibt gleich die closure-Funktion zurück!
    return function() {
        return wert;
    };
}

let b = f3(); // b ist wieder die von f3() zurückgegebene Funktion ...
console.log(b()); // ... und liefert jetzt als Ergebnis 23
console.log(b); // b bleibt aber weiterhin ein Funktionsaufruf!
console.log(f3()()); // liefert ebenfalls 23
</syntaxhighlight>
Die eingebettete Funktion dient jeweils als Lieferant des in der übergeordneten Funktion definierten Wertes.

Die übergeordnete Funktion kann auch als [[anonyme Funktion]] definiert werden:
<syntaxhighlight lang="javascript">
let wert = 24;

let c = (function() { // die äußere als anonyme Funktion und ...
    return wert;        // ... darin die innere Funktion definieren.
}());                   // die Funktion jetzt noch mit (); aufrufen.

console.log(c);         // ergibt 24
</syntaxhighlight>

Die Closure kann auch mit einer Konstruktorfunktion erzeugt werden:
<syntaxhighlight lang="javascript">
let d = (new Function("return wert;"))();   // mit einem Konstruktor definieren und aufrufen
</syntaxhighlight>

=== Lua ===

[[Lua]] hat eine eingebaute und im Sinne der Programmierung auch intuitiv nutzbare Unterstützung für Closures, deren Implementierung ähnlich derjenigen in Python ist:
<syntaxhighlight lang="lua">
function adder(x)      -- Funktionserzeuger
    return function(y) -- anonyme, zu adder private Funktion
        return x+y     -- x stammt hier aus dem äußeren Kontext
    end
end
</syntaxhighlight>

Eine Beispielnutzung sähe so aus:
<syntaxhighlight lang="lua">
add2 = adder(2)    -- hier wird die Closure erzeugt
print(add2(10))    --> Ausgabe 12
print(add2(-2))    --> Ausgabe 0
</syntaxhighlight>

Eine Closure-Implementierung in Lua ist in<ref>The implementation of Lua 5.0</ref> beschrieben.

=== Erlang ===
[[Erlang (Programmiersprache)|Erlang]] als funktionale Sprache besitzt ebenfalls Closures, die allerdings ''Funs'' (Singular ''Fun'', von ''function'') genannt werden.

<syntaxhighlight lang="erlang">
do_something(Fun) -> Fun(4).

main() ->
    Var = 37,
    F = fun(N) -> Var + N end.
    Result = do_something(F).
    % Result =:= 41 =:= 37 + 4
</syntaxhighlight>

=== C# ===
[[C-Sharp|C#]] unterstützt Closures in Form von [[Delegation (Softwareentwicklung)|Delegates]].<ref>{{Internetquelle |autor=Dustin Campbell |url=http://diditwith.net/PermaLink,guid,235646ae-3476-4893-899d-105e4d48c25b.aspx |titel=What’s In A Closure |datum=2007-02-09 |sprache=en |offline=1 |archiv-url=https://web.archive.org/web/20140815085318/http://diditwith.net/PermaLink,guid,235646ae-3476-4893-899d-105e4d48c25b.aspx |archiv-datum=2014-08-15 |abruf=2014-04-12}}</ref>

<syntaxhighlight lang="csharp">
private static Action CreateClosure()
{
    // Deklaration einer Variablen im lokalen Kontext
    var x = 0;

    // Erstellung eines Closure-Delegate mit Hilfe eines Lambda-Ausdrucks
    Action closure = () => Console.WriteLine(x);

    // Änderung am lokalen Kontext
    x = 1;

    // Rückgabe der Closure in den übergeordneten Kontext
    return closure;
}

static void Main()
{
    var closure = CreateClosure();

    // Im globalen Kontext
    // Variable x wird nur noch innerhalb der Closure referenziert

    // Führe Closure aus; Schreibt "1" auf die Konsole
    closure();
}
</syntaxhighlight>

=== C++ ===
[[C++]] unterstützt Closures mittels Lambda-Ausdrücken<ref>{{Internetquelle |url=https://en.cppreference.com/w/cpp/language/lambda |titel=Lambda functions |sprache=en |abruf=2015-10-17}}</ref> (ab C++11), die sich in [[C++-Standardbibliothek#Funktionsobjekte|Funktionsobjekte]], sogenannte Funktoren, des Typs std::function kapseln lassen.
<syntaxhighlight lang="cpp">
#include <string>
#include <iostream>
#include <functional>

std::function<void(void)> create_closure() {
    std::string kuchen("Apfelkuchen");

    // Lokale Variablen werden hier als Kopie in das Funktionsobjekt übertragen
    return [=]() { std::cout << "Ich esse " << kuchen << std::endl; };
}

int main() {
    std::function<void(void)> closure = create_closure();
    closure();

    return 0;
}
</syntaxhighlight>
Mit Hilfe des Schlüsselworts '''mutable''' kann aus einer Lambda-Funktion eine echte Closure erstellt werden, die nicht nur ihre eigenen Variablen besitzt, sondern diese auch verändern kann (die Variable „anzahl_kuchen“ im äußeren Block wird dabei jedoch nicht verändert, sondern nur eine Kopie davon):
<syntaxhighlight lang="cpp">
#include <iostream>
#include <functional>

std::function<void(void)> mutterfunktion() {
    int anzahl_kuchen = 0;

    // Die übernommene Kopie der Variable kann hier zusätzlich ihren Wert verändern.
    return [=]() mutable { std::cout << "Ich esse " << ++anzahl_kuchen << " Kuchen.\n"; };
}

int main() {
    std::function<void(void)> essen = mutterfunktion();

    essen();
    essen();
    essen();

    return 0;
}
</syntaxhighlight>
Ausgabe dieses Programms:
<pre>
Ich esse 1 Kuchen.
Ich esse 2 Kuchen.
Ich esse 3 Kuchen.
</pre>

=== Java ===
In [[Java (Programmiersprache)|Java]] sind ab der Version 8 ebenfalls Closures möglich, wobei dabei einige spezifische Annahmen der Sprache über Lambda-Ausdrücke zu beachten sind. Der folgende Code würde zum Beispiel nicht [[Java (Programmiersprache)#Compiler|kompilieren]].
<syntaxhighlight lang="Java">
private static Function<String, Supplier<String>> generator = kuchenname -> {
    int zähler = 0;
    return () -> "Ich esse " + zähler++ + " " + kuchenname; // Fehler: zähler kann nicht geändert werden
};

public static void main(String[] args) {
    Supplier<String> käsekuchen = generator.apply("Käsekuchen");

    System.out.println(käsekuchen.get());
    System.out.println(käsekuchen.get());
    System.out.println(käsekuchen.get());
}
</syntaxhighlight>

In Java kann der Code innerhalb eines Lambda-Ausdrucks lesend auf die Variablen der umschließenden Methode zugreifen, kann sie jedoch nicht verändern. Im obigen Beispiel versucht der Code des zurückgegebenen Suppliers, durch <code>zähler++</code> den Wert einer Variable zu ändern, was einen Compilerfehler auslöst. Um diese Einschränkung zu umgehen, müssen Daten, die verändert werden, in Objekten gekapselt werden, zum Beispiel mit AtomicInteger:
<syntaxhighlight lang="Java">
private static Function<String, Supplier<String>> generator = kuchenname -> {
    AtomicInteger zähler = new AtomicInteger(0);
    return () -> "Ich esse " + zähler.getAndIncrement() + " " + kuchenname;
};

public static void main(String[] args) {
    Supplier<String> käsekuchen = generator.apply("Käsekuchen");

    System.out.println(käsekuchen.get());
    System.out.println(käsekuchen.get());
    System.out.println(käsekuchen.get());
}
</syntaxhighlight>

Der so korrigierte Code kompiliert, da die Referenz auf das Zählerobjekt im Lambda-Ausdruck unverändert bleibt. Die Ausgabe ist dann:

<pre>
Ich esse 0 Käsekuchen
Ich esse 1 Käsekuchen
Ich esse 2 Käsekuchen
</pre>

=== PHP ===
[[PHP]] unterstützt Closures ab Version 5.3.0 in Form anonymer Funktionen.<ref>{{Internetquelle |url=https://www.php.net/manual/de/functions.anonymous.php |titel=Anonymous functions |sprache=de |abruf=2015-05-19}}</ref>

Technisch löst PHP die Umsetzung dieser Funktionalität durch eine eigene „Closure“-Klasse.<ref>{{Internetquelle |url=https://www.php.net/manual/de/class.closure.php |titel=The Closure class |sprache=de |abruf=2015-05-19}}</ref>

<syntaxhighlight lang="php">
$mutterfunktion = function() {
    $anzahl_kuchen = 0;

    $kindfunktion = function() use (&$anzahl_kuchen) {
        $anzahl_kuchen = $anzahl_kuchen + 1;
        print "Ich esse {$anzahl_kuchen} Kuchen\n";
    };

    return $kindfunktion;
};

$essen = $mutterfunktion();
$essen();
$essen();
$essen();
</syntaxhighlight>

Die Ausgabe der Aufrufe lautet wie folgt:

<pre>
Ich esse 1 Kuchen
Ich esse 2 Kuchen
Ich esse 3 Kuchen
</pre>

Ab PHP 7.0 werden Closures zusätzlich auch in Form anonymer Klassen unterstützt.<ref>{{Internetquelle |autor=Joe Watkin, Phil Sturgeon |url=https://wiki.php.net/rfc/anonymous_classes |titel=Anonymous Classes |datum=2013-09-22 |sprache=en |abruf=2015-05-19}}</ref>

<syntaxhighlight lang="php">
$essen = new class() {
    private $anzahl_kuchen = 0;

    public function __invoke() {
        $this->anzahl_kuchen = $this->anzahl_kuchen + 1;
        print "Ich esse {$this->anzahl_kuchen} Kuchen\n";
    }
};

$essen();
$essen();
$essen();
</syntaxhighlight>

Beide Implementierungen liefern identische Ausgaben.

=== Rust ===
[[Rust (Programmiersprache)|Rust]] unterstützte Closures bereits ab Version 0.1, die Rückgabe von Closures aus Funktionen musste bis zu Rust 1.26 (veröffentlicht am 10. Mai 2018) über einen Zeiger auf den Heap-Speicher (via <code>Box</code>) geschehen.

<syntaxhighlight lang="rust">
fn mutterfunktion() -> Box<dyn FnMut() -> ()> {
    let mut anzahl_kuchen = 0;

    let kindfunktion = move || {
        anzahl_kuchen += 1;
        println!("Ich esse {} Kuchen", anzahl_kuchen);
    };

    // [Ex.1] Fehler wenn anzahl_kuchen nicht Copy implementieren würde (s.u.)
    // println!("Jetzt ist die Anzahl der Kuchen: {}", anzahl_kuchen);

    return Box::new(kindfunktion);
}

fn main() {
    let mut essen = mutterfunktion();
    essen();
    essen();
    essen();
}
</syntaxhighlight>

Ausgabe:
<pre>
Ich esse 1 Kuchen
Ich esse 2 Kuchen
Ich esse 3 Kuchen
</pre>

In Rust 1.26 wurde die <code>impl Trait</code> [[Syntax]] stabilisiert, welche den gleichen Code ohne Indirektion via Heap-Speicher (<code>Box::new()</code>) ermöglicht:

<syntaxhighlight lang="rust">
fn mutterfunktion() -> impl FnMut() -> () {
    let mut anzahl_kuchen = 0;

    move || {
        anzahl_kuchen += 1;
        println!("Ich esse {} Kuchen", anzahl_kuchen);
    }
}

fn main() {
    let mut essen = mutterfunktion();
    essen();
    essen();
    essen();
}
</syntaxhighlight>

Hierbei „implementiert“ der Rückgabewert von <code>mutterfunktion()</code> den <code>Fn</code> trait, wobei die Ermittlung des exakten Typs des Rückgabewerts erst bei der Nutzung der Funktion erfolgt.

Rust differenziert hierbei zwischen Funktionszeigern und Closures, sowie verschiedenen Closure-Typen: <code>Fn</code>, <code>FnMut</code> und <code>FnOnce</code>. Eine <code>Fn</code>-Closure kann den Kontext, in dem sie aufgerufen wird, nicht modifizieren. Eine <code>FnMut</code>-Closure kann die Variable im Kontext nur modifizieren, wenn diese als <code>mut</code> gekennzeichnet wurde. Eine <code>FnOnce</code>-Closure konsumiert die im Kontext erstellte Variable. Hierbei könnte <code>essen()</code> nur exakt einmal aufgerufen werden – am Ende der ersten Closure läuft der Destruktor von <code>anzahl_kuchen</code> und die Variable ist damit nicht mehr verfügbar.

Wenn <code>[Ex.1]</code> auskommentiert wird, ergibt die Ausgabe:

<pre>
Jetzt ist die Anzahl der Kuchen: 0
Ich esse 1 Kuchen
Ich esse 2 Kuchen
Ich esse 3 Kuchen
</pre>

Das <code>move</code> Schlüsselwort wird gebraucht um den Besitz der Variable <code>anzahl_kuchen</code> anzuzeigen. Da unsere Variable <code>anzahl_kuchen</code> kopierbar ist (Variablen des Typs <code>u32</code> implementieren den <code>Copy</code>-Trait), können wir die Variable innerhalb der Mutterfunktion noch verwenden, nachdem der eigentliche Wert der Closure übergeben wurde. Hierbei wird <code>anzahl_kuchen</code> kopiert, d.&nbsp;h. obwohl wir im Code die Anzahl bereits auf 1 gesetzt haben, gibt die Ausgabe noch 0 aus, da es eine komplette Kopie der Variable ist. Ist der Typ von <code>anzahl_kuchen</code> nicht kopierbar, gibt der Compiler einen Fehler aus.

=== Scala ===
[[Scala (Programmiersprache)|Scala]] ist eine funktionale Programmiersprache auf Basis der [[Java Virtual Machine]].

<syntaxhighlight lang="scala">
object ClosureTest {

   def main(args: Array[String]): Unit = {

      def  kindfunktion = mutterfunktion
      println("Calling Kinder")

      kindfunktion;
      kindfunktion;
      kindfunktion;
}

	var anzahl_kuchen = 0;
	def mutterfunktion : Unit = {

	  var kuchentype = "Apfelkuchen"

	  def kindfunktion : Unit = {
	    anzahl_kuchen = anzahl_kuchen + 1
	    return System.out.println("Ich esse " + anzahl_kuchen.toString() +  " " + kuchentype)
	  }
	  kindfunktion
	}
}
</syntaxhighlight>
Hierbei ist die Variable ''anzahl_kuchen'' über Aufrufe hinweg nur veränderlich, wenn sie in einem globalen Kontext (durchaus auch in einer anderen Klasse oder einem anderen Objekt) definiert wurde. Die Ausgabe des Programms lautet:
<pre>
Calling Kinder
Ich esse 1 Apfelkuchen
Ich esse 2 Apfelkuchen
Ich esse 3 Apfelkuchen
</pre>

== Literatur ==
* Ralf H. Güting, Martin Erwig, ''Übersetzerbau''. Springer, 1999, ISBN 3-540-65389-9
* [[Damian Conway]], ''Object Oriented Perl''
* Oliver Lau, Andreas Linke, Torsten T. Will: ''Variablen to go – Closures in aktuellen Programmiersprachen.'' In: ''[[c’t]]'', 17/2013, S. 168ff.

== Weblinks ==
* [http://www.iqool.de/Was-ist-eine-Closure.html ''Was ist eine Closure?'']

== Einzelnachweise ==
<references />

[[Kategorie:Programmierkonzept]]