JavaScript भाषा में सबसे बड़े बज़वर्ड्स में से एक है क्लोजर (closure)। यह FAANG कंपनियों में कई जॉब इंटरव्यू सवालों का विषय है। इस आर्टिकल में, हम क्लोजर और स्कोप के बारे में बात करेंगे, सरल उदाहरणों के साथ इसकी अवधारणाओं को चित्रित करेंगे, और फिर बड़ी टेक कंपनियों में से एक के साथ एक इंटरव्यू से एक सैंपल सवाल के साथ समाप्त करेंगे।
Scope (स्कोप)
जब कोई आपको बताता है कि कोई चीज़ किसी प्रोजेक्ट के दायरे में है या नहीं, तो इसका क्या मतलब है?
मैं इसके उत्तर के बारे में सोचते समय एक पेरिस्कोप या टेलीस्कोप के बारे में सोचना पसंद करूंगा। ये उपकरण हमें लेंस की सीमा के भीतर सभी प्रकार की चीजें दिखाते हैं: यह स्कोप में है। यदि यह स्कोप के बाहर है, तो आप लेंस के व्यास से आगे नहीं देख सकते। और लेंस के व्यास के बाहर किसी चीज़ पर रोशनी डालना संभव नहीं है। जैसा कि हम JavaScript में तीन बहुत महत्वपूर्ण और विशिष्ट प्रकार के स्कोप के बारे में बात करते हैं, आपको इस बारे में सोचना चाहिए: लोकल, ग्लोबल और लेक्सिकल।
लोकल स्कोप (Local Scope)
लोकल स्कोप उन तीन स्कोप्स में से सबसे छोटा है जिनके बारे में हम आज बात करेंगे। जब हम एक फंक्शन घोषित करते हैं, तो ब्रैकेट्स ({}) के अंदर कुछ भी फंक्शन के लिए स्थानीय माना जाता है। जब JavaScript इंजन फंक्शन को पढ़ता है तो यह वेरिएबल्स की घोषणा करेगा; जब यह समाप्त होता है तो यह वेरिएबल्स को नष्ट कर देगा।
function greeting() {
var websiteName = 'Career Karma';
return `Hello ${websiteName}`;
}
console.log(greeting()); // Hello Career Karma
console.log(websiteName); // ReferenceError: websiteName is not defined
जैसा कि आप देख सकते हैं, जब हम आमंत्रित ग्रीटिंग फंक्शन के परिणाम को "console.log()" करते हैं, तो हम फंक्शन के निष्पादित होने के बाद websiteName को एक्सेस करने में सक्षम होते हैं। यह हमें वह 'Hello Career Karma' स्ट्रिंग देता है जिसे हम ढूंढ रहे थे। फंक्शन के अंदर घोषित वेरिएबल के console.log() से एक त्रुटि होती है क्योंकि यह परिभाषित नहीं है।
जैसा कि पहले ही उल्लेख किया गया है, websiteName अपरिभाषित क्यों है इसका कारण यह है कि वेरिएबल्स फंक्शन के अंदर तब बनाए जाते हैं जब उन्हें इनवोक किया जाता है और फिर टर्मिनल स्टेटमेंट चलने पर नष्ट हो जाते हैं। फंक्शन के बाहर कुछ भी फंक्शन के अंदर की चीजों तक पहुंच नहीं रखता जब तक कि उसका एक विशेष सेटअप न हो।
ग्लोबल स्कोप (Global Scope)
यह अगला स्कोप वाक्यांश का बहुत अधिक शाब्दिक अनुवाद है। एक ग्लोबल स्कोप फंक्शन के बाहर घोषित आइटम्स को लेता है और उन्हें एक ऐसी जगह में आरक्षित करता है जहां सभी स्क्रिप्ट्स और मेथड्स और फंक्शन्स उन्हें अपने लॉजिक के लिए एक्सेस और उपयोग कर सकते हैं।
let counter = 0; // ग्लोबल -- फंक्शन के बाहर घोषित
const add = () => {
// फंक्शन घोषणा
let counter = 0; // लोकल -- फंक्शन के अंदर घोषित
counter += 1; // काउंटर 1 से बढ़ा -- कौन सा काउंटर वेरिएबल बढ़ा?
return counter;
}
add(); // add() को इनवोक करें
add(); // तीन बार
add(); //
console.log(counter) // यह 3 है या 0? क्यों?
उपरोक्त कोड क्या करता है यदि हम कोड के अंत में काउंटर को console.log() करते हैं? आप क्या होने की उम्मीद करते हैं?
आइए कोड के माध्यम से चलते हैं:
- ग्लोबल एनवायरनमेंट में काउंटर वेरिएबल घोषित और आरंभ किया गया।
- ग्लोबल एनवायरनमेंट में Add फंक्शन घोषित।
- Add को इनवोक किया गया।
- लोकल एनवायरनमेंट में काउंटर वेरिएबल घोषित और आरंभ किया गया।
- लोकल काउंटर 1 से बढ़ा ⇐ लोकल क्यों और ग्लोबल क्यों नहीं?
- काउंटर लौटाया गया। फंक्शन समाप्त।
- Add को फिर से इनवोक किया गया
- चरण 4 से 6 फिर से चलें।
- चरण 3 से 6 दोहराएं।
console.log(counter); ⇐ क्या लौटाया गया?
क्योंकि फंक्शन तब समाप्त होता है जब काउंटर हर बार 1 पर होता है, हमारा लोकल काउंटर वेरिएबल हर बार फंक्शन चलने पर पुन: घोषित और 0 पर पुन: आरंभ होता है। चाहे कुछ भी हो, काउंटर हमेशा लोकल स्तर पर 1 पर रुकेगा।
यदि कोई फंक्शन अपने स्कोप के भीतर एक वेरिएबल ढूंढता है, तो यह उस वेरिएबल के लिए ग्लोबल स्कोप को नहीं देखता – इसलिए ग्लोबल वेरिएबल कभी नहीं बदलता। इसलिए, हमारा console.log() 0 को आउटपुट करेगा क्योंकि उस स्टेटमेंट के एनवायरनमेंट के भीतर निकटतम परिभाषित वेरिएबल ग्लोबल एनवायरनमेंट में है।
लेक्सिकल स्कोप (Lexical Scope)
लेक्सिकल स्कोप JavaScript में सबसे मौलिक अवधारणाओं में से एक है। यह विचार है कि एक फंक्शन या वेरिएबल का निर्माण कोड के कुछ हिस्सों के लिए सुलभ होगा और फिर कोड के अन्य हिस्सों के लिए दुर्गम होगा। यह सब इस बात पर निर्भर करता है कि प्रत्येक वेरिएबल और फंक्शन की घोषणा कहां है।
आइए कोड के इस ब्लॉक को देखें:
const init = () => {
// <== यह हमारा बाहरी फंक्शन है
const var1 = 'Career'; // बाहरी स्कोप
const second = () => {
// <== यह हमारा आंतरिक फंक्शन है
const var2 = 'Karma'; // आंतरिक स्कोप
console.log(var1); // Career
console.log(var2); // Karma
return var1 + " " + var2;
};
// console.log(var2); // undefined
return second();
};
init();
यहां हमारे पास नेस्टेड फंक्शन्स का एक सेट है। init() फंक्शन var1 नामक एक वेरिएबल घोषित करता है, second नामक एक फंक्शन घोषित करता है और second() को इनवोक करता है।
जब कंपाइलर पहली बार इस कोड से गुजरता है, तो यह एक उच्च-स्तरीय नज़र डालता है कि हमारे पास क्या है:
init()फंक्शनinit()इनवोक करें
इस बिंदु पर, हम init() फंक्शन के अंदर कुछ और नहीं देख सकते – हम सिर्फ जानते हैं कि फंक्शन मौजूद है। जब हमारा init() फंक्शन इनवोक होता है, तो कंपाइलर फंक्शन के अंदर क्या है, इस पर एक और उच्च-स्तरीय नज़र डालता है:
var1second()फंक्शनsecond()इनवोक करें
init() फंक्शन को इस बात का कोई पता नहीं है कि second() ब्लॉक के अंदर क्या चल रहा है। यह केवल वही देख सकता है जो इसके लेक्सिकल एनवायरनमेंट में है – इसकी आसपास की स्थिति।
प्रत्येक नेस्टेड फंक्शन एक छोटे कंटेनर में होता है, जैसे रूसी मैट्रियोश्का नेस्टिंग डॉल्स का एक सेट। डॉल्स केवल वही जानती हैं जो उनके कंटेनर के अंदर चल रहा है और पैरेंट में पहले से क्या हुआ या घोषित/पढ़ा गया है। सबसे बड़ी डॉल उदाहरण के लिए केवल यह जानती है कि उसके कंटेनर में अगली डॉल मौजूद है। यह सेट में किसी अन्य डॉल के बारे में नहीं जानती, बस अपने लेक्सिकल एनवायरनमेंट (इसकी स्थिति) में क्या है और क्या पहले ही हो चुका है (बाहरी स्कोप)।
संक्षेप में, हम दो बातें जानते हैं:
- बाहरी स्कोप आंतरिक स्कोप को नहीं देख सकता।
- आंतरिक स्कोप की बाहरी स्कोप तक पहुंच है।
क्योंकि बाहरी स्कोप आंतरिक स्कोप में क्या चल रहा है यह नहीं देख सकता, हम सुरक्षित रूप से कह सकते हैं कि यह एक तरफा रिश्ता है। आंतरिक बाहरी स्कोप से वेरिएबल्स देख और उपयोग कर सकता है, लेकिन बाहरी आंतरिक को नहीं देख सकता। इसे लेक्सिकल स्कोप कहा जाता है।
लेक्सिकल स्कोपिंग की सुंदरता यह है कि एक वेरिएबल का मान कोड में इसके प्लेसमेंट द्वारा निर्धारित किया जाता है। फंक्शन्स पहले अपने लोकल एनवायरनमेंट के अंदर एक वेरिएबल का अर्थ ढूंढते हैं – यदि वे इसे नहीं ढूंढ पाते, तो वे उस फंक्शन पर चले जाते हैं जिसने उस फंक्शन को परिभाषित किया। यदि वे इसे वहां नहीं ढूंढ पाते, तो वे चेन को अगले परिभाषित फंक्शन तक ले जाते हैं।
यह JavaScript में एक बहुत महत्वपूर्ण अवधारणा बन जाती है जो बार-बार आएगी जैसे-जैसे आप JavaScript फ्रेमवर्क्स और वे कैसे काम करते हैं, उनके बारे में अधिक सीखते हैं। आप बाहरी से नीचे पास कर सकते हैं, लेकिन आप दूसरी दिशा में "ऊपर" कभी पास नहीं कर सकते। यह बहुत महत्वपूर्ण है क्योंकि हम मुख्य विषय पर पहुंचते हैं: क्लोजर (Closure)।
क्लोजर (Closure)
क्लोजर की परिभाषा लेक्सिकल स्कोप के समान है। दोनों के बीच मुख्य अंतर यह है कि क्लोजर एक हायर-ऑर्डर फंक्शन है और लेक्सिकल स्कोपिंग नहीं है। एक हायर-ऑर्डर फंक्शन की एक बुनियादी विशेषता होती है: यह या तो एक फंक्शन लौटाता है या एक फंक्शन को पैरामीटर के रूप में उपयोग करता है।
क्लोजर एक फंक्शन है जो अपने लेक्सिकल स्कोप तक पहुंच सकता है, तब भी जब उस फंक्शन को बाद में इनवोक किया जा रहा हो।
क्लोजर और लेक्सिकल स्कोप दोनों के अपने स्वयं के वेरिएबल्स होते हैं, पैरेंट फंक्शन के वेरिएबल्स और पैरामीटर्स तक पहुंच सकते हैं, और ग्लोबल वेरिएबल्स का उपयोग कर सकते हैं। आइए निम्न कोड के माध्यम से चलते हैं:
function greeting() {
// बाहरी स्कोप (पैरेंट फंक्शन)
const userName = "CrrKrma1952"; // पैरेंट वेरिएबल
function welcomeGreeting() {
// आंतरिक फंक्शन
console.log("Hello, " + userName); // पैरेंट वेरिएबल एक्सेस करता है
return "Hello, " + userName; // टर्मिनल स्टेटमेंट
}
return welcomeGreeting; // एक फंक्शन लौटाता है (जो इसे HOF बनाता है)
}
// greeting() का अंत
const greetUser = greeting();
// greetUser(); // Hello, CrrKrma1952
greeting()फंक्शन मौजूद है, लेकिन हम अभी तक सामग्री नहीं जानते।greetUserमौजूद है, लेकिन सामग्री नहीं जानतेgreetUser()– यह पिछली लाइन को इनवोक करता है, जो बदले में greeting() फंक्शन को इनवोक करता है।- userName घोषित
welcomeGreeting()मौजूद है, लेकिन सामग्री नहीं जानतेwelcomeGreeting()ब्लॉक के नीचे रिटर्न स्टेटमेंट वही फंक्शन लौटाता हैconsole.log('Hello, ' + userName); हमारा console.log यहां पैरेंट स्कोप को एक्सेस करके userName का मान प्राप्त कर सकता है- टर्मिनल स्टेटमेंट जो फंक्शन को समाप्त करता है और कोड ब्लॉक के अंदर वेरिएबल्स के अर्थ को नष्ट करता है।
इस कोड में, हम फंक्शन्स को एक साथ नेस्ट करके जानकारी पास कर रहे हैं ताकि पैरेंट स्कोप को बाद में एक्सेस किया जा सके।
निष्कर्ष
इस आर्टिकल में, हमने एक बहुत भारी JavaScript विषय के बारे में बात की: Scope और Closures। मैं विभिन्न दृष्टिकोणों से इस विषय पर कई अलग-अलग आर्टिकल्स पढ़ने की सलाह दूंगा। इसे पढ़ाने का तरीका विभिन्न दृष्टिकोणों से आ सकता है – जिसका अर्थ है, निश्चित रूप से, कि इसे सीखने के बहुत सारे तरीके हैं। मुझे उम्मीद है कि यह प्राइमर आपके लिए मददगार था! क्लोजर पर अपना अध्ययन जारी रखने में शुभकामनाएं!