दिलचस्प पोस्ट
JFreeChart – चलती चार्ट बनाने में समस्या इनपुट के भीतर JQuery Datatables खोज और चयन करें क्या अपलोड करने से पहले छवि के आयामों को जांचना संभव है? base64 एन्कोडेड छवि आकार @ मूल (वैकल्पिक = गलत) बनाम @ कॉलम (नाले = झूठे) जेपीए में PHP में – (डबल बृहदान्त्र) और -> (तीर) के बीच अंतर क्या है? क्षैतिज लाइनरलेआउट में (ऊर्ध्वाधर) विभक्त कैसे जोड़ें? जावास्क्रिप्ट में एक `नल` मान क्यों है? जेएसएफ बैकिंग बीन स्ट्रक्चर (सर्वोत्तम अभ्यास) शून्य में शून्य सूचक के लिए पॉइंटर अंकगणित कैसे कीपैड पॉपअप अक्षम करने के लिए जब edittext पर? सी – कमांड लाइन पैरामीटर पढ़ना बॉट फ़्रेमवर्क को एम्बेडेड चैट कंट्रोल पेज के ServiceUrl मिलता है सभी अजीब स्थित तत्वों को बाएं आधे भाग में ले जाएं और यहां तक ​​कि सही आधा जगह पर तैनात हैं एंड्रॉइड प्ले सेवाओं 6.5: स्थान क्लाइंट गायब है

एक 'क्लोजर' क्या है?

मैंने करीरी और बंद होने के बारे में एक सवाल पूछा था। एक बंद क्या है? यह कैसे करी से संबंधित है?

Solutions Collecting From Web of "एक 'क्लोजर' क्या है?"

परिवर्तनीय अवसर

जब आप एक स्थानीय चर घोषित करते हैं, तो उस चर में एक गुंजाइश होती है। आम तौर पर स्थानीय चर केवल उस ब्लॉक या फ़ंक्शन के भीतर मौजूद होते हैं जिसमें आप उन्हें घोषित करते हैं।

function() { var a = 1; console.log(a); // works } console.log(a); // fails 

यदि मैं एक स्थानीय चर तक पहुंचने का प्रयास करता हूं, तो अधिकांश भाषाओं इसके लिए मौजूदा दायरे में देखेंगे, फिर मूल स्कॉप्स के माध्यम से जब तक वे रूट स्कोप तक पहुंच न जाएंगे।

 var a = 1; function() { console.log(a); // works } console.log(a); // works 

जब किसी ब्लॉक या फ़ंक्शन के साथ किया जाता है, तो उसके स्थानीय चर की जरुरत नहीं होती है और आमतौर पर स्मृति से उड़ा होता है

हम आम तौर पर काम करने के लिए अपेक्षा करते हैं।

एक बंद एक स्थाई स्थानीय चर का गुंजाइश है

एक क्लोजर एक निरंतर दायरा है जो कोड निष्पादन उस ब्लॉक से बाहर निकल जाने के बाद भी स्थानीय चर पर रखता है। जिन भाषाओं में क्लोजर (जैसे जावास्क्रिप्ट, स्विफ्ट और रूबी) का समर्थन होता है, वे आपको उस ब्लॉक के बाद भी, जिसमें वे वेरिएबल्स घोषित किए गए हैं, जो कार्य निष्पादित कर चुके हैं, के दायरा के संदर्भ को रखने के लिए अनुमति देगा। उस ब्लॉक या फ़ंक्शन कहीं

दायरा वस्तु, और इसके सभी स्थानीय चर, फ़ंक्शन से जुड़े होते हैं, और जब तक वह कार्य जारी रहती है तब तक जारी रहती है।

यह हमें फ़ंक्शन पोर्टेबिलिटी देता है हम किसी भी वेरिएबल की उम्मीद कर सकते हैं जो कार्यकाल में थे जब फ़ंक्शन को पहले से परिभाषित किया गया था जब हम फ़ंक्शन को कॉल करते हैं, भले ही हम फ़ंक्शन को पूरी तरह से अलग संदर्भ में कहते हैं।

उदाहरण के लिए

यहां जावास्क्रिप्ट में एक बहुत आसान उदाहरण है जो इस बिंदु को दर्शाता है:

 outer = function() { var a = 1; var inner = function() { console.log(a); } return inner; // this returns a function } var fnc = outer(); // execute outer to get inner fnc(); 

यहां मैंने फ़ंक्शन के भीतर फ़ंक्शन परिभाषित की है। आंतरिक फ़ंक्शन सभी बाहरी फ़ंक्शन के स्थानीय चर तक पहुंच देता है, जिसमें a वेरिएबल A आंतरिक फ़ंक्शन के लिए दायरे में है।

आम तौर पर जब कोई फ़ंक्शन निकलता है, तो उसके सभी स्थानीय चर को उड़ा दिया जाता है। हालांकि, यदि हम आंतरिक फ़ंक्शन वापस करते हैं और इसे एक चर fnc आवंटित करते हैं, तो यह outer बाहर निकल जाने के बाद बनी रहती है, इन सभी चर जो कि inner परिभाषित किए गए थे, तब भी मौजूद थे । चर a पर बंद कर दिया गया है – यह समापन के भीतर है

ध्यान दें कि चर a है fnc लिए पूरी तरह से निजी है यह जावास्क्रिप्ट जैसे कार्यात्मक प्रोग्रामिंग भाषा में निजी चर बनाने का एक तरीका है।

जैसा कि आप अनुमान लगा सकते हैं, जब मैं fnc() कॉल fnc() हूँ तो यह fnc() के मान को प्रिंट करता a , जो "1" है।

बिना बंद किए भाषा में, चर a कचरा इकट्ठा होता और फेंक दिया जाता था जब फ़ंक्शन outer बाहर निकल जाता था। कॉलिंग एफएनसी ने एक त्रुटि डाल दी होगी क्योंकि अब मौजूद नहीं है

जावास्क्रिप्ट में, चर a बनी रहती है क्योंकि फ़ंक्शन को पहले घोषित किया जाता है, और जब तक फ़ंक्शन चालू होना जारी रहता है तब तक चर गुंजाइश बनाई जाती है।

a outer के दायरे के अंतर्गत आता है inner के दायरे में outer के दायरे में एक मूल सूचक है। fnc एक वेरिएबल है जो inner इंगित करता है। a लंबे समय तक बनी रहती है जब तक कि fnc जारी नहीं रहती है। a समापन के भीतर है।

मैं एक उदाहरण देता हूं (जावास्क्रिप्ट में):

 function makeCounter () { var count = 0; return function () { count += 1; return count; } } var x = makeCounter(); x(); returns 1 x(); returns 2 ...etc... 

यह फ़ंक्शन क्या करता है, मुकाबला करता है, क्या यह एक फ़ंक्शन देता है, जिसे हमने एक्स कहा है, जो प्रत्येक बार इसकी कॉल की गणना करेगा चूंकि हम एक्स को कोई पैरामीटर नहीं प्रदान कर रहे हैं इसलिए किसी भी तरह गिनती याद रखना चाहिए। यह पता है कि इसे किस प्रकार लेक्सिकल स्कोपिंग कहा जाता है, इसके आधार पर पता होना चाहिए – इसे उस स्थान पर देखना चाहिए जहां उसे मूल्य खोजने के लिए परिभाषित किया गया है। यह "छुपा" मान है जिसे क्लोजर कहा जाता है

यहाँ मेरा कारीटिंग उदाहरण फिर से है:

 function add (a) { return function (b) { return a + b; } } var add3 = add(3); add3(4); returns 7 

आप क्या देख सकते हैं कि जब आप पैरामीटर ए (जो 3 है) के साथ जोड़ते हैं, तो उस वैल्यू में लौटा फ़ंक्शन के समापन में समाहित होता है जिसे हम add3 होने के लिए परिभाषित कर रहे हैं इस तरह, जब हम add3 को कॉल करते हैं, तो यह जानने के लिए कि इसके अलावा इसके प्रदर्शन के लिए एक मूल्य कहां मिल सकता है।

काइल का उत्तर बहुत अच्छा है मुझे लगता है कि एकमात्र अतिरिक्त स्पष्टीकरण यह है कि समापन मूल रूप से स्टैकेट का एक स्नैपशॉट है जिस पर लैम्ब्डा फ़ंक्शन बनता है। तब फ़ंक्शन को पुन: निष्पादित करने के बाद फ़ंक्शन कार्यान्वित करने से पहले उस स्थिति में स्टैक बहाल हो जाता है। इस प्रकार काइल के रूप में उल्लेख किया गया है, कि लम्बेडा फ़ंक्शन निष्पादित होने पर उस छिपी हुई मान ( count ) उपलब्ध है।

एक बंद एक समारोह है जो किसी अन्य समारोह में राज्य को संदर्भित कर सकता है। उदाहरण के लिए, पायथन में, यह "आंतरिक" को बंद करता है:

 def outer (a): b = "variable in outer()" def inner (c): print a, b, c return inner # Now the return value from outer() can be saved for later func = outer ("test") func (1) # prints "test variable in outer() 1 

क्लोजर को समझने में मदद करने के लिए यह जांचना उपयोगी हो सकता है कि उन्हें प्रक्रियागत भाषा में कैसे लागू किया जा सकता है। यह विवरण योजना में बंद होने के सरलीकृत कार्यान्वयन का पालन करेगा।

शुरू करने के लिए, मुझे एक नेमस्पेस की अवधारणा को प्रस्तुत करना चाहिए। जब आप किसी योजना दुभाषिया में एक आदेश दर्ज करते हैं, तो उसे अभिव्यक्ति में विभिन्न प्रतीकों का मूल्यांकन करना चाहिए और उनका मूल्य प्राप्त करना चाहिए। उदाहरण:

 (define x 3) (define y 4) (+ xy) returns 7 

परिभाषित एक्सप्लोरेशन को वैल्यू 3 को एक्स के लिए जगह में और वाई के लिए वैल्यू 4 में स्टोर करना चाहिए। तब जब हम (+ xy) कॉल करते हैं, तो दुभाषिया नाम स्थान में मान दिखता है और ऑपरेशन करने और 7 पर लौटने में सक्षम है।

हालांकि, योजना में ऐसी अभिव्यक्तियां हैं जो आपको अस्थायी रूप से एक प्रतीक के मूल्य को ओवरराइड करने की अनुमति देती हैं। यहां एक उदाहरण है:

 (define x 3) (define y 4) (let ((x 5)) (+ xy)) returns 9 x returns 3 

क्या जाने वाला कीवर्ड एक्स के साथ एक नया नेमस्पेस 5 मान के रूप में पेश करता है। आप देखेंगे कि यह अभी भी यह देखने में सक्षम है कि y 4 है, जिससे राशि 9 हो जाएगी। आप यह भी देख सकते हैं कि अभिव्यक्ति एक्स वापस 3 होने जा रहा है। इस अर्थ में, एक्स को स्थानीय मूल्य द्वारा अस्थायी रूप से मुखौटा दिया गया है।

प्रक्रियात्मक और वस्तु उन्मुख भाषाओं की एक समान अवधारणा है जब भी आप एक फ़ंक्शन में एक वैरिएबल घोषित करते हैं जिसका वैश्विक वैरिएबल जैसा एक ही नाम होता है तो आप उसी प्रभाव को प्राप्त करते हैं।

हम इसे कैसे लागू करेंगे? एक सरल तरीका एक लिंक्ड सूची के साथ है – सिर में नया मान होता है और पूंछ में पुरानी नाम स्थान है। जब आपको एक प्रतीक देखने की जरूरत है, तो आप सिर से शुरू करते हैं और पूंछ के नीचे अपना रास्ता काम करते हैं।

अब पल के लिए प्रथम श्रेणी के कार्यों के कार्यान्वयन को छोड़ दें। अधिक या कम, फ़ंक्शन निष्पादित करने के निर्देशों का एक सेट होता है, जब फ़ंक्शन को वापसी मान में समापन कहा जाता है। जब हम फ़ंक्शन में पढ़ते हैं, तो हम इन निर्देशों को पर्दे के पीछे रख सकते हैं और फ़ंक्शन को कॉल करते समय उन्हें चला सकते हैं।

 (define x 3) (define (plus-x y) (+ xy)) (let ((x 5)) (plus-x 4)) returns ? 

हम एक्स 3 को परिभाषित करते हैं और प्लस-एक्स को इसके पैरामीटर, y, प्लस एक्स के मान अंत में हम एक ऐसे वातावरण में प्लस-एक्स कहते हैं जहां एक्स को एक नया एक्स के साथ मुखौटा लगाया गया है, यह एक महत्वपूर्ण मानी गई है। अगर हम परिसर में हैं, तो हम फ़ंक्शन प्लस-एक्स के लिए (+ xy) ऑपरेशन स्टोर करते हैं, क्योंकि हम संदर्भ में हैं एक्स के 5 होने का परिणाम 9 होगा। यह गतिशील स्कॉपींग कहलाता है।

हालांकि, स्कीम, कॉमन लिस्प, और अन्य कई भाषाओं में लिक्सिकल स्कोपिंग कहलाता है- ऑपरेशन को संचय करने के अलावा- (+ xy) हम उस विशिष्ट बिंदु पर नाम स्थान भी संग्रहीत करते हैं। इस तरह, जब हम मूल्यों को देख रहे हैं हम देख सकते हैं कि एक्स, इस संदर्भ में, वास्तव में 3 है। यह एक बंद है

 (define x 3) (define (plus-x y) (+ xy)) (let ((x 5)) (plus-x 4)) returns 7 

संक्षेप में, हम फंक्शन परिभाषा के समय नामस्थान की स्थिति को स्टोर करने के लिए एक लिंक्ड सूची का उपयोग कर सकते हैं, जिससे हमें स्कोपों ​​को बंद करने से चर का उपयोग करने की इजाजत मिल सकती है, साथ ही हमें स्थानीय रूप से शेष को प्रभावित किए बिना एक वैरिएबल को मुखर करने की क्षमता प्रदान कर सकते हैं। कार्यक्रम।

सबसे पहले, जो लोग यहां बताते हैं, इसके विपरीत, समापन कोई फ़ंक्शन नहीं है ! तो यह क्या है ?
यह फ़ंक्शन के "आसपास के संदर्भ" में परिभाषित प्रतीकों का एक सेट है (जिसे उसके पर्यावरण के रूप में जाना जाता है ) जो इसे बंद अभिव्यक्ति (अर्थात, एक अभिव्यक्ति है जिसमें हर प्रतीक परिभाषित किया गया है और एक मूल्य है, इसलिए इसे मूल्यांकन किया जा सकता है)।

उदाहरण के लिए, जब आपके पास जावास्क्रिप्ट फ़ंक्शन होता है:

 function closed(x) { return x + 3; } 

यह एक बंद अभिव्यक्ति है क्योंकि इसमें सभी प्रतीकों को परिभाषित किया गया है (उनके अर्थ स्पष्ट हैं), ताकि आप इसका मूल्यांकन कर सकें। दूसरे शब्दों में, यह स्वयं निहित है

लेकिन अगर आपके पास ऐसा फ़ंक्शन है:

 function open(x) { return x*y + 3; } 

यह एक खुली अभिव्यक्ति है क्योंकि इसमें प्रतीकों को परिभाषित नहीं किया गया है। अर्थात्, y इस समारोह को देखते हुए, हम यह नहीं बता सकते कि y क्या है और इसका क्या अर्थ है, हम इसका मूल्य नहीं जानते हैं, इसलिए हम इस अभिव्यक्ति का मूल्यांकन नहीं कर सकते। यानी हम इस समारोह को तब तक नहीं बुला सकते जब तक हम यह नहीं बताते कि इसमें क्या मतलब है। यह y को एक निःशुल्क चर कहा जाता है।

यह y एक परिभाषा के लिए भीख मांगता है, लेकिन यह परिभाषा फ़ंक्शन का हिस्सा नहीं है – यह कहीं और परिभाषित की जाती है, इसके "आसपास के संदर्भ" (जिसे पर्यावरण के रूप में भी जाना जाता है ) में। कम से कम हम इसके लिए आशा करते हैं: पी

उदाहरण के लिए, यह विश्व स्तर पर परिभाषित किया जा सकता है:

 var y = 7; function open(x) { return x*y + 3; } 

या इसे एक फ़ंक्शन में परिभाषित किया जा सकता है जो इसे लपेटता है:

 var global = 2; function wrapper(y) { var w = "unused"; return function(x) { return x*y + 3; } } 

पर्यावरण का एक हिस्सा जो एक अभिव्यक्ति में उनके अर्थों में मुफ्त चर देता है, बंद है । इसे इस तरह से कहा जाता है, क्योंकि यह एक बंद में एक खुली अभिव्यक्ति को बदलता है, इन सभी बेतरतीब परिभाषाओं को अपने सभी मुफ्त चर के लिए प्रदान करके , ताकि हम इसका मूल्यांकन कर सकें।

ऊपर दिए गए उदाहरण में, आंतरिक फ़ंक्शन (जो हमने एक नाम नहीं दिया क्योंकि हमें इसकी आवश्यकता नहीं थी) एक खुली अभिव्यक्ति है क्योंकि इसमें वाईरियर y मुफ़्त है – इसकी परिभाषा फ़ंक्शन के बाहर है, जो फ़ंक्शन में होती है यह। उस अनाम फ़ंक्शन के लिए वातावरण चर का सेट है:

 { global: 2, w: "unused", y: [whatever has been passed to that wrapper function as its parameter `y`] } 

अब, समापन इस पर्यावरण का एक हिस्सा है, जो अपने सभी मुफ्त चर के लिए परिभाषाओं को प्रदान करके आंतरिक फ़ंक्शन को बंद कर देता है। हमारे मामले में, आंतरिक फ़ंक्शन में एकमात्र फ्री वेरिएबल y था, इसलिए उस फ़ंक्शन को बंद करना इसके पर्यावरण का सबसेट है:

 { y: [whatever has been passed to that wrapper function as its parameter `y`] } 

पर्यावरण में परिभाषित अन्य दो प्रतीकों उस समारोह के समापन का हिस्सा नहीं हैं, क्योंकि उन्हें चलाने की आवश्यकता नहीं है। उन्हें इसे बंद करने की आवश्यकता नहीं है

इसके पीछे सिद्धांत पर और अधिक: https://stackoverflow.com/a/36878651/434562

यह ध्यान देने योग्य है कि ऊपर दिए गए उदाहरण में, आवरण समारोह अपने आंतरिक फ़ंक्शन को एक मूल्य के रूप में देता है। फिलहाल हम इस फ़ंक्शन को कॉल करते हैं, फिलहाल फ़ंक्शन को परिभाषित किया गया है (या बनाया गया) से समय में दूरस्थ हो सकता है विशेष रूप से, इसकी रैपिंग फ़ंक्शन अब नहीं चल रही है, और उसके मापदंड जो कॉल स्टैक पर हैं, वहां अब नहीं हैं: पी यह एक समस्या बनाता है, क्योंकि इन्हें भी कहा जाता है जब आंतरिक फ़ंक्शन की आवश्यकता होती है! दूसरे शब्दों में, इसके बंद होने से वेरिएबल्स की आवश्यकता होती है ताकि किसी तरह आवरण समारोह से निकल जाए और वहां की आवश्यकता हो। इसलिए, आंतरिक फ़ंक्शन को इन वेरिएबल्स का एक स्नैपशॉट बनाना होगा जो इसे बंद कर देते हैं और बाद में उपयोग के लिए उन्हें कहीं सुरक्षित सुरक्षित रखते हैं। (कॉल स्टैक के बाहर कहीं।)

और यही कारण है कि लोगों को इस अवधि के समापन को भ्रमित करने के लिए उस विशेष प्रकार का फ़ंक्शन कहा जाता है जो कि वे बाहरी चर का उपयोग करते हैं, या बाद में इन वैरिएबलों को संग्रहीत करने के लिए उपयोग किए जाने वाले डेटा संरचना का उपयोग कर सकते हैं। लेकिन मुझे आशा है कि आप समझते हैं कि वे खुद को बंद नहीं कर रहे हैं – वे प्रोग्रामिंग भाषा या भाषा तंत्र में बंद होने को तैयार करने के तरीके हैं, जो फ़ंक्शन के बंद होने से चर की आवश्यकता होती है, जब वहां की आवश्यकता होती है। समापन के आसपास कई गलत धारणाएं हैं (अनावश्यक रूप से) इस विषय को अधिक भ्रमित और जटिल बनाते हुए यह वास्तव में है।

यहाँ एक वास्तविक दुनिया उदाहरण है कि क्यों क्लोज़र्स लात मारना … यह सीधे मेरे जावास्क्रिप्ट कोड से बाहर है मुझे उदाहरण दें।

 Function.prototype.delay = function(ms /*[, arg...]*/) { var fn = this, args = Array.prototype.slice.call(arguments, 1); return window.setTimeout(function() { return fn.apply(fn, args); }, ms); }; 

और यहां बताया गया है कि आप इसका उपयोग कैसे करेंगे:

 var startPlayback = function(track) { Player.play(track); }; startPlayback(someTrack); 

अब कल्पना कीजिए कि आप प्लेबैक को विलंबित करने के लिए चाहते हैं, जैसे कि इस कोड स्निपेट रन के बाद 5 सेकंड बाद। अच्छी तरह से delay साथ आसान है और यह बंद है:

 startPlayback.delay(5000, someTrack); // Keep going, do other things 

जब आप 5000 एमएस के साथ delay करते हैं, तो पहला स्निपेट चलता रहता है, और इसे बंद होने के बावजूद तर्क दिया जाता है। तब 5 सेकंड बाद में, जब setTimeout कॉलबैक होता है, तो क्लोजर अभी भी उन चर को बनाए रखता है, इसलिए यह मूल पैरामीटर के साथ मूल फ़ंक्शन को कॉल कर सकता है।
यह एक प्रकार का करीयन या फ़ंक्शन सजावट है।

बंद होने के बिना, आपको फ़ंक्शन के बाहर उन वेरिएबल्स को बनाए रखना होगा, इस प्रकार इस समारोह के बाहर कोड को कूड़ा बनायेगा जो तार्किक रूप से इसके अंदर आता है। क्लोजर का उपयोग करना आपके कोड की गुणवत्ता और पढ़ने योग्यता में काफी सुधार कर सकती है।

सामान्य परिस्थिति में, चर को स्कॉपिंग नियम से बाध्य किया जाता है: लोकल चर केवल परिभाषित फ़ंक्शन के भीतर काम करते हैं। सुविधा सुविधा के लिए अस्थायी रूप से इस नियम को तोड़ने का एक तरीका है।

 def n_times(a_thing) return lambda{|n| a_thing * n} end 

उपरोक्त कोड में, lambda(|n| a_thing * n} बंद है क्योंकि a_thing को लैम्ब्डा (एक अनाम फ़ंक्शन निर्माता) द्वारा निर्दिष्ट किया जाता है।

अब, यदि आप परिणामी गुमनाम समारोह को फ़ंक्शन चर में डालते हैं।

 foo = n_times(4) 

फू सामान्य स्कोपिंग नियम को तोड़ देगा और 4 आंतरिक रूप से उपयोग करना शुरू कर देगा

 foo.call(3) 

12 रिटर्न

फ़्री व्हेरिएबल्स वाले फ़ंक्शंस को शुद्ध कार्यों कहा जाता है

एक या अधिक नि: शुल्क चर वाले कार्यों को बंद कहा जाता है

 var pure = function pure(x){ return x // only own environment is used } var foo = "bar" var closure = function closure(){ return foo // foo is a free variable from the outer environment } 

स्रोत: https://leanpub.com/javascriptallongesix/read#leanpub-auto-if-functions-without-free-variables-are-pure-are-closures-impure

संक्षेप में, फ़ंक्शन पॉइंटर प्रोग्राम कोड बेस (जैसे प्रोग्राम काउंटर) में स्थान के लिए एक सूचक है। जबकि क्लोजर = फंक्शन पॉइंटर + स्टैक फ्रेम

tl; डॉ

एक समापन एक फ़ंक्शन होता है और उसके आवंटन को एक चर के रूप में (या प्रयोग किया जाता है) आवंटित किया जाता है। इस प्रकार, नाम बंद करना: कार्यक्षेत्र और कार्य संलग्न है और किसी भी अन्य इकाई की तरह उपयोग किया जाता है।

गहराई में विकिपीडिया शैली विवरण

विकिपीडिया के अनुसार, एक समापन है:

प्रथम-श्रेणी के कार्यों के साथ भाषाओं में बाइक्सिंग को मौलिक रूप से स्कॉड नाम लागू करने की तकनीकें

इसका क्या मतलब है? चलो कुछ परिभाषाओं पर गौर करें

मैं इस उदाहरण का उपयोग करके बंद और अन्य संबंधित परिभाषाओं का समझाऊंगा:

 function startAt(x) { return function (y) { return x + y; } } var closure1 = startAt(1); var closure2 = startAt(5); console.log(closure1(3)); // 4 (x == 1, y == 3) console.log(closure2(3)); // 8 (x == 5, y == 3) 

यहां एक और वास्तविक जीवन उदाहरण है, और खेलों में लोकप्रिय पटकथा भाषा का उपयोग करना – लुआ मुझे स्टडीन के साथ समस्या से बचने के लिए जिस तरह से एक लाइब्रेरी फ़ंक्शन काम करता है, उसमें थोड़ा बदलाव करने की आवश्यकता है I

 local old_dofile = dofile function dofile( filename ) if filename == nil then error( 'Can not use default of stdin.' ) end old_dofile( filename ) end 

पुरानी _ डीफ़ाइल का मान गायब हो जाता है जब कोड के इस ब्लॉक को यह गुंजाइश खत्म हो जाता है (क्योंकि यह स्थानीय है), हालांकि मूल्य समापन में बंद किया गया है, इसलिए नए पुन: परिभाषित dofile फ़ंक्शन इसे उपयोग कर सकता है या फ़ंक्शन के साथ संग्रहीत एक प्रति 'upvalue'।

Lua.org से :

जब किसी फ़ंक्शन को किसी अन्य फ़ंक्शन में संलग्न किया जाता है, तो उसके पास संलग्न फ़ंक्शन से स्थानीय चर तक पूर्ण पहुंच होती है; इस विशेषता को लैक्सिकल स्कोपिंग कहा जाता है हालांकि यह स्पष्ट लग सकता है, ऐसा नहीं है। लेक्सिकल स्कोपिंग, प्लस प्रथम श्रेणी फ़ंक्शंस, प्रोग्रामिंग भाषा में एक शक्तिशाली अवधारणा है, लेकिन कुछ भाषाओं को इस अवधारणा का समर्थन है।

यदि आप जावा दुनिया से हैं, तो आप एक क्लास के सदस्य फ़ंक्शन के साथ बंद होने की तुलना कर सकते हैं। इस उदाहरण को देखें

 var f=function(){ var a=7; var g=function(){ return a; } return g; } 

फ़ंक्शन g एक बंद है: g में एक बंद g है। इसलिए g को किसी सदस्य फ़ंक्शन के साथ तुलना की जा सकती है, किसी वर्ग के क्षेत्र से तुलना की जा सकती है, और कक्षा के साथ फ़ंक्शन फ़ंक्शन।

क्लोज़र्स जब भी हमारे पास किसी अन्य फ़ंक्शन के अंदर परिभाषित फ़ंक्शन है, तो आंतरिक फ़ंक्शन को बाह्य फ़ंक्शन में घोषित वेरिएबल्स तक पहुंच है। क्लोज़रों को सर्वोत्तम उदाहरणों के साथ समझाया गया है लिस्टिंग 2-18 में, आप देख सकते हैं कि आंतरिक फ़ंक्शन के पास बाह्य क्षेत्र से एक चर (variableInOuterFunction) तक पहुंच है बाहरी फ़ंक्शन में वेरिएबल आंतरिक फ़ंक्शन द्वारा (या बाध्य) बंद कर दिए गए हैं। इसलिए शब्द समापन। अपने आप में अवधारणा काफी सरल और काफी सहज है

 Listing 2-18: function outerFunction(arg) { var variableInOuterFunction = arg; function bar() { console.log(variableInOuterFunction); // Access a variable from the outer scope } // Call the local function to demonstrate that it has access to arg bar(); } outerFunction('hello closure!'); // logs hello closure! 

स्रोत: http://index-of.es/Varios/Basarat%20Ali%20Syed%20(auth.)-Beginning%20Node.js-Appre%20(2014).pdf