Mi a bezárás?

_{(Jogi nyilatkozat: ez egy alapvető magyarázat; a definícióhoz képest egy kicsit leegyszerűsítem)}

A bezárás legegyszerűbb módja egy függvény, amely változóként tárolható (“első” néven -class függvény “), amely különleges képességgel rendelkezik a helyi változók eléréséhez abban a körben, amelyben létrehozták.

Példa (JavaScript):

 var setKeyPress = function(callback) { document.onkeypress = callback; }; var initialize = function() { var black = false; document.onclick = function() { black = !black; document.body.style.backgroundColor = black ? "#000000" : "transparent"; } var displayValOfBlack = function() { alert(black); } setKeyPress(displayValOfBlack); }; initialize();  

A document.onclick és a iv id funkcióhoz rendelt ¹ függvényeket = “3fee5ad5ad”>

A bezárás alapvetően csak egy objektum nézésének más módja. Az objektum olyan adat, amelyhez egy vagy több funkció kapcsolódik. A bezárás egy olyan függvény, amelyhez egy vagy több változó kapcsolódik. A kettő alapvetően azonos, legalábbis megvalósítási szinten. A valódi különbség abban rejlik, hogy honnan származnak.

Az objektumorientált programozásban deklarál egy objektumosztályt úgy, hogy előre meghatározza annak tagváltozóit és módszereit (tagfüggvényei), majd létrehozza a az osztály. Minden példányhoz tartozik a tagadatok másolata, amelyet a konstruktor inicializál. Ezután van egy objektumtípusú változója, és adattáblázatként adja át, mert a hangsúly az adat jellegén van.

A bezárásnál viszont az objektum nem előre definiálva, mint egy objektum osztály, vagy példányosítva van egy konstruktor hívással a kódban. Ehelyett a bezárást egy másik függvénybe írja be. A bezárás hivatkozhat a külső függvény bármelyik helyi változójára, és a fordító ezt észleli, és ezeket a változókat a külső függvény veremterületéről a bezárás rejtett objektum deklarációjára helyezi át. Ezután van egy zárási típusú változója , és bár ez alapvetően egy tárgy a motorháztető alatt, függvényreferenciaként adja át, mert a hangsúly a függvény jellegén van.

Megjegyzések

• +1: Jó válasz. A lezárást csak egy metódussal rendelkező objektumként, egy tetszőleges objektumot pedig a közös mögöttes adatok (az objektum ‘ s tagváltozói) feletti bezárások gyűjteményeként tekintheti meg. Szerintem ez a két nézet meglehetősen szimmetrikus.
• Nagyon jó válasz. Ez valójában megmagyarázza a bezárás betekintését.
• @Mason Wheeler: Hol tárolják a bezárási adatokat? Veremben, mint egy függvény? Vagy halomban, mint egy tárgy?
• @RoboAlex: A kupacban, mert ‘ olyan objektum, amely kinéz függvény .
• @RoboAlex: A bezárás és a rögzített adatok tárolási helye a megvalósítástól függ. A C ++ nyelven a kupacban vagy a veremben tárolható.

A bezárás abból származik, hogy egy kódrész (blokk, függvény) szabad változókat tartalmazhat, amelyek zárt (azaz egy értékhez kötött) azzal a környezettel, amelyben a kódblokk definiálva van.

Vegyük például a Scala függvénydefiníciót :

def addConstant(v: Int): Int = v + k 

A függvénytörzsben két név (változó) található: v és k két egész értéket jelöl. A v név azért van kötve, mert a addConstant függvény argumentumaként van deklarálva (a függvény deklarációjának megtekintésével tudjuk, hogy v értéket kap a függvény meghívásakor). A (z) k név szabadon írta a addConstant függvényt, mert a függvény nem tartalmaz nyomot arra vonatkozóan, hogy a k kötődik (és hogyan).

Ahhoz, hogy értékelni lehessen egy ilyen hívást:

val n = addConstant(10) 

hozzá kell rendelnünk a k egy érték, amely csak akkor történhet meg, ha a k nevet abban a kontextusban definiáljuk, amelyben addConstant van definiálva. Például:

def increaseAll(values: List[Int]): List[Int] = { val k = 2 def addConstant(v: Int): Int = v + k values.map(addConstant) } 

Most, hogy meghatároztuk a addConstant kontextust, ahol k definiálva van, addConstant bezárássá vált mert szabad változói zárt (értékhez kötöttek): addConstant hívni és átadni, mintha egy funkció lenne. Vegye figyelembe, hogy a k szabad változó egy értékhez van kötve, amikor a bezárás meghatározott , míg az v argumentumváltozó akkor van kötve, ha a bezárás .

Tehát a bezárás alapvetően olyan funkció vagy kódblokk, amely szabad változókon keresztül férhet hozzá a nem helyi értékekhez, miután ezeket a kontextus lekötötte.

Sok nyelven, ha csak akkor használjon lezárást, ha névtelenné teheti , pl.

def increaseAll(values: List[Int]): List[Int] = { val k = 2 values.map(v => v + k) } 

Ne feledje, hogy egy szabad változó nélküli függvény a bezárás speciális esete (a szabad változók üres halmazával). Hasonlóképpen, egy névtelen függvény egy névtelen bezárás speciális esete , vagyis az anonim függvény anonim bezárás, szabad változók nélkül.

Megjegyzések

• Ez jól értelmezhető a logika zárt és nyitott képleteivel. Köszönöm a válaszod.
• @RainDoctor: A szabad változókat a logikai képletek és a lambda calculus kifejezések hasonló módon definiálják: a lambda kifejezésben szereplő lambda úgy működik, mint egy kvantor a logikai képletekben, amelyek szabad / kötött változókat írtak le. .

Egyszerű magyarázat a JavaScript-ben:

var closure_example = function() { var closure = 0; // after first iteration the value will not be erased from the memory // because it is bound with the returned alertValue function. return { alertValue : function() { closure++; alert(closure); } }; }; closure_example(); 

alert(closure) a closure korábban létrehozott értékét fogja használni. A visszaadott alertValue függvény névtere összekapcsolódik azzal a névtérrel, amelyben a closure változó található. A teljes függvény törlésével a A closure változó értéke törlődik, de addig a alertValue függvény mindig képes lesz a változó értékének olvasására / írására closure.

Ha futtatja ezt a kódot, az első iteráció 0 értéket rendel a closure változóhoz, és írja át a függvényt a következőre:

var closure_example = function(){ alertValue : function(){ closure++; alert(closure); } } 

És mivel alertValue szüksége van a closure a függvény végrehajtásához összeköti magát a korábban hozzárendelt closure helyi változó értékével.

És most minden alkalommal, amikor meghívja a closure_example függvény, kiírja a closure változó növelt értékét, mert alert(closure) kötött.

closure_example.alertValue()//alerts value 1 closure_example.alertValue()//alerts value 2 closure_example.alertValue()//alerts value 3 //etc. 

Megjegyzések

• köszönöm, nem tettem ‘ t tesztelje a kódot =) minden rendben van.

A “bezárás” , lényegében néhány helyi állam és valamilyen kód, csomagba egyesítve. Jellemzően a helyi állapot egy környező (lexikális) hatókörből származik, és a kód (lényegében) egy belső függvény, amelyet aztán visszavezetnek a külsőbe. A bezárás a rögzített változók, amelyeket a belső függvény lát, és a belső függvény kódjainak kombinációja.

Ez egy olyan dolog, amelyet sajnos kissé nehéz megmagyarázni, mivel ismeretlen.

Az egyik hasonlóság, amelyet a múltban sikeresen alkalmaztam, az volt: “képzelje el, hogy van valami, amit” könyvnek “hívunk, a szoba bezárásakor,” a könyv “az a másolat ott, a sarokban , de az asztalzárásnál ez a Dresden Files könyv egy példánya. Tehát attól függően, hogy milyen bezárásban van, az “adj nekem könyvet” kód különböző dolgokat eredményez. “

Megjegyzések

• Ezt elfelejtette: hu.wikipedia.org/wiki/Closure_(computer_programming) a válaszodban.
• Nem, jóindulatúan úgy döntöttem, hogy nem zárom be az oldalt.
• ” Állapot és funkció. “: Zárható-e egy static helyi változóval rendelkező C függvény? Haskellben jár-e állapot?
• @Giorgio A Haskell-i bezárások (úgy gondolom) lezárják azokat a lexikális hatókörű érveket, amelyeket ‘ definiáltak, tehát, én ‘ d mondd ” igen ” (bár a legjobb esetben sem ismerem Haskellt). A statikus változóval rendelkező AC funkció a legjobb esetben nagyon korlátozott bezárás (nagyon szeretné, ha egyetlen funkcióból több zárást is létrehozhatna, egy static helyi változóval. pontosan egy).
• Ezt a kérdést szándékosan tettem fel, mert úgy gondolom, hogy a statikus változóval rendelkező C függvény nem záródás: a statikus változót helyileg definiálják, és csak a bezáráson belül ismert, nem fér hozzá a környezet. Emellett nem vagyok 100% -ig biztos, de fordítva fogalmaznám meg az állításodat: a bezárási mechanizmust használod különböző függvények létrehozásához (a függvény egy bezárási definíció + egy kötés a szabad változóihoz).

Nehéz meghatározni, hogy mi a bezárás, anélkül, hogy meghatároznánk az “állam” fogalmát.

Alapvetően , a teljes lexikális hatókörű, a funkciókat első osztályú értékként kezelő nyelven valami különleges történik. Ha ilyet tennék:

function foo(x) return x end x = foo 

A x változó nemcsak a function foo(), de hivatkozik arra az állapotra is, amikor foo a legutóbbi visszaadáskor maradt. Az igazi varázslat akkor következik be, amikor foo további funkciók vannak tovább meghatározva a hatókörén belül; olyan, mint a saját mini-környezete (ugyanúgy, ahogy “normálisan” definiáljuk a függvényeket egy globális környezetben).

Funkcionálisan sok olyan problémát megoldhat, mint a C ++ (C) “statikus” kulcsszó, amely megőrzi a helyi változó állapotát a többfunkciós hívás során; ez azonban inkább hasonlít ugyanarra az elvre (statikus változó) egy függvényre, mivel a függvények első osztályú értékek; a bezárás hozzáadja a teljes mentendő állapot állapotát (semmi köze a C ++ statikus függvényeihez).

A függvények első osztályú értékként való kezelése és a bezárások támogatásának hozzáadása azt is jelenti, hogy ugyanaz a funkció egynél több példánya lehet a memóriában (hasonlóan az osztályokhoz). Ez azt jelenti, hogy újra felhasználhatja a ugyanazt a kódot anélkül, hogy vissza kellene állítania a függvény állapotát, amire szükség van a függvényen belüli C ++ statikus változók kezeléséhez (lehet, hogy téved ebben?).

Íme néhány teszt a Lua bezárási támogatásáról .

--Closure testing --By Trae Barlow -- function myclosure() print(pvalue)--nil local pvalue = pvalue or 10 return function() pvalue = pvalue + 10 --20, 31, 42, 53(53 never printed) print(pvalue) pvalue = pvalue + 1 --21, 32, 43(pvalue state saved through multiple calls) return pvalue end end x = myclosure() --x now references anonymous function inside myclosure() x()--nil, 20 x() --21, 31 x() --32, 42 --43, 53 -- if we iterated x() again 

eredmények:

nil 20 31 42 

Lehet trükkös, és valószínűleg változik nyelvről nyelvre, de a Lua-ban úgy tűnik, hogy amikor egy funkciót végrehajtanak, annak állapota visszaáll. Ezt azért mondom, mert a fenti kód eredménye más lenne, ha a függvény / állapot közvetlenül (anonim függvényen keresztül, ahová visszatér), mivel a pvalue visszaáll 10-re; de ha hozzáférünk a myclosure állapotához az x-en keresztül (az anonim függvény), akkor láthatja, hogy a pvalue életben van és jól van valahol a memóriában. Gyanítom, hogy van benne még valami, talán valaki jobban meg tudja magyarázni a megvalósítás természetét.

PS: Nem ismerek egy C ++ 11 nyalást (a korábbi verziók kivételével), ezért vegye figyelembe, hogy ez nem összehasonlítás a C ++ 11-es és a Lua-i bezárások között. Ezenkívül az összes Lua-tól C ++ -ig húzott “vonal” hasonlóság, mivel a statikus változók és a zárások nem 100% -ban azonosak; még akkor is, ha néha hasonló problémák megoldására használják őket.

Az a dolog, amiben nem vagyok biztos, a fenti kódpéldában az, hogy az anonim vagy a magasabb rendű függvényt tekintjük-e bezárásnak?

A bezárás egy olyan funkció, amelynek társított állapota van:

Perl-ben ilyen bezárásokat hoz létre:

#!/usr/bin/perl # This function creates a closure. sub getHelloPrint { # Bind state for the function we are returning. my ($first) = @_;a # The function returned will have access to the variable $first return sub { my ($second) = @_; print "$first $second\n"; }; } my $hw = getHelloPrint("Hello"); my $gw = getHelloPrint("Goodby"); &$hw("World"); // Print Hello World &$gw("World"); // PRint Goodby World 

Ha megnézzük a C ++ szolgáltatással kapott új funkciókat.
Ez lehetővé teszi az aktuális állapot hozzárendelését az objektumhoz:

#include <string> #include <iostream> #include <functional> std::function<void(std::string const&)> getLambda(std::string const& first) { // Here we bind `first` to the function // The second parameter will be passed when we call the function return [first](std::string const& second) -> void { std::cout << first << " " << second << "\n"; }; } int main(int argc, char* argv[]) { auto hw = getLambda("Hello"); auto gw = getLambda("GoodBye"); hw("World"); gw("World"); } 

Nézzük meg egy egyszerű függvényt:

function f1(x) { // ... something } 

Ezt a függvényt legfelső szintű függvénynek hívják, mert nem fészkel be más funkciókat. Minden A JavaScript függvény hozzárendeli az objektumok listáját, az úgynevezett ” hatókörlánc “ nevet. Ez a hatókörlánc rendezett objektumlista Ezen objektumok ach meghatároz néhány változót.

A legfelső szintű függvényekben a hatókörlánc egyetlen objektumból, a globális objektumból áll. Például a fenti f1 függvénynek van egy hatókörlánca, amelyben egyetlen objektum van, amely meghatározza az összes globális változót. (vegye figyelembe, hogy az “objektum” kifejezés itt nem JavaScript objektumot jelent, csupán egy megvalósítás által definiált objektum, amely változó konténerként működik, amelyben a JavaScript “meg tudja keresni” a változókat.)

Amikor ez függvény meghívásra kerül, a JavaScript létrehoz egy úgynevezett “aktiválási objektumot” , és a hatókörlánc tetejére helyezi. Az objektum tartalmazza az összes helyi változót (például x itt). Ezért most két objektum van a hatókörben: az első az aktiválási objektum, alatta pedig a globális objektum.

Nagyon óvatosan vegye figyelembe, hogy a két objektum MÁSODIK alkalommal kerül a hatókörbe. A globális objektum akkor kerül be, amikor a függvény definiálva van (azaz amikor a JavaScript elemzi a függvényt és létrehozza a függvényobjektumot), és az aktiválási objektum a függvény meghívásakor lép be.

Tehát, ezt már tudjuk:

• Minden függvényhez tartozik egy hatókörlánc
• Amikora függvény definiálva (a függvényobjektum létrehozásakor), a JavaScript elment egy hatókörláncot ezzel a függvénnyel.
• A legfelső szintű függvényeknél a hatókörlánc csak a globális objektumot tartalmazza a függvénydefiníció idején, és további hozzáad aktiválási objektum a tetején, meghíváskor

A helyzet akkor válik érdekessé, ha beágyazott függvényekkel foglalkozunk. Tehát hozzunk létre egyet:

function f1(x) { function f2(y) { // ... something } } 

Amikor a f1 meghatározódik, kapunk egy hatókörláncot, amely tartalmazza csak a globális objektum.

Most, amikor f1 meghívásra kerül, az f1 hatókörlánc megkapja az aktiválási objektumot. Ez az aktiválási objektum tartalmazza a x változót és a f2 változót, amely egy függvény. És vegye figyelembe, hogy f2 egyre definiálódik.Ezért ezen a ponton a JavaScript egy új hatókörláncot is elment a f2 számára. Ehhez a belső függvényhez mentett hatókörlánc a hatályos hatókörlánc. A jelenlegi hatókör A tulajdonképpeni lánc a f1 “sé. Ezért f2” hatókörét f1 “s aktuális hatókörlánc – amely a f1 aktiválási objektumát tartalmazza és a globális objektumot.

A f2 meghívásakor megkapja a saját aktiválási objektumát, amely y, hozzáadva a hatóköréhez, amely már tartalmazza a f1 aktiválási objektumot és a globális objektumot.

Ha a f2, a hatókörlánc három objektumot tartalmazna a meghatározás idején (két külső függvény 2 aktiválási objektumát és a globális objektumot), és 4-et a meghívás időpontjában.

Tehát, most alulmegyünk tandard a hatókörlánc működését, de még nem beszéltünk a bezárásokról.

A függvényobjektum és a hatókör (változó kötések halmaza) kombinációja amelyben a függvény változói fel vannak oldva, a számítástechnikai szakirodalomban bezárásnak nevezzük – JavaScript a végleges útmutató David Flanagan

A legtöbb függvényt ugyanazon hatókörlánc segítségével hívják meg, amely a funkció definiálásakor volt érvényben, és nem mindegy, hogy lezárás van. A bezárások akkor válnak érdekessé, ha más hatókörű láncra hivatkoznak, mint amely a definiálásukkor érvényben volt. Ez akkor fordul elő leggyakrabban, amikor egy beágyazott függvényobjektum visszatér abból a funkcióból, amelyen belül definiálták.

Amikor a függvény visszatér, az aktiválási objektum eltávolításra kerül a hatókör láncából. Ha nem voltak beágyazott függvények, nincs több hivatkozás az aktiválási objektumra, és szemetet gyűjt. Ha vannak beágyazott függvények definiálva, akkor mindegyik függvény hivatkozik a hatókör láncra, és ez a hatókör lánc az aktiválási objektumra utal.

Ha ezek a beágyazott funkciók objektumok a külső függvényükön belül maradtak, akkor maguk is szemetet gyűjtenek, az aktiválási objektummal együtt, amelyre hivatkoztak. De ha a függvény definiál egy beágyazott függvényt, és visszaadja, vagy valahol egy tulajdonságba tárolja, akkor külső hivatkozás lesz a beágyazott függvényre. Ez nem lesz szemetet gyűjtve, és az általa hivatkozott aktiválási objektum sem lesz szemét.

A fenti példánkban nem térünk vissza f2 from f1, ezért amikor az f1 címre érkező hívás visszatér, aktiválási objektuma eltávolításra kerül a hatóköréből és az összegyűjtött szemét. De ha lenne valami ilyesmi:

function f1(x) { function f2(y) { // ... something } return f2; } 

Itt a visszatérő f2 lesz egy hatókörlánc, amely tartalmazzák az f1 aktiválási objektumot, és ezért nem lesz szemét. Ezen a ponton, ha hívjuk a f2 -t, akkor hozzáférhet a f1 “változóhoz x annak ellenére, hogy túl vagyunk f1.

Ezért láthatjuk, hogy egy függvény megtartja a hatókörét és a hatókörét jöjjön a külső függvények összes aktiválási objektuma. Ez a bezárás lényege. Azt mondjuk, hogy a JavaScriptben szereplő függvények “lexikailag hatókörűek” , vagyis mentik azt a hatókört, amely akkor volt aktív, amikor meghatározták őket, szemben azzal a hatókörrel, amely akkor volt aktív, amikor felhívták őket.

Számos hatékony programozási technika létezik, amelyek bezárással járnak, például a privát változók közelítése , eseményvezérelt programozás, részleges alkalmazás stb.

Ne feledje, hogy mindez vonatkozik mindazokra a nyelvekre, amelyek támogatják a bezárásokat. Például PHP (5.3+), Python, Ruby stb.