कीवर्ड var कई वर्षों से जावास्क्रिप्ट में वेरिएबल घोषित करने का डिफ़ॉल्ट तरीका रहा है। हालाँकि, इसमें कई विचित्रताएँ और खामियाँ हैं जो आपके कोड में अप्रत्याशित व्यवहार का कारण बन सकती हैं। लेट और कॉन्स्ट जैसे आधुनिक विकल्प इनमें से कई समस्याओं का समाधान करते हैं, जिससे वे ज्यादातर मामलों में वेरिएबल घोषित करने के लिए पसंदीदा विकल्प बन जाते हैं।

1️⃣ उत्थापन: var आपके जानने से पहले ही वेरिएबल घोषित कर देता है!

? स्पष्टीकरण:

जावास्क्रिप्ट में, var घोषणाओं को उनके दायरे के शीर्ष पर फहराया जाता है, जिसका अर्थ है कि उन्हें अपरिभाषित के रूप में प्रारंभ किया जाता है, भले ही घोषणा बाद में कोड में दिखाई दे। इससे भ्रमित करने वाला व्यवहार हो सकता है और ऐसे बग पैदा हो सकते हैं जिनका पता लगाना कठिन है।

? प्रमुख बिंदु:

• ? होस्टिंग इन एक्शन: परिवर्तनीय घोषणाओं को दायरे के शीर्ष पर ले जाया जाता है, लेकिन उनके असाइनमेंट को नहीं।
• ? अप्रत्याशित अपरिभाषित मान: मान निर्दिष्ट करने से पहले वेरिएबल का उपयोग किया जा सकता है, जिससे अनपेक्षित अपरिभाषित परिणाम प्राप्त होते हैं।

? उदाहरण:

console.log(myVar);  // undefined (hoisted but not initialized)
var myVar = 10;
console.log(myVar);  // 10

? टिप्पणी: वेरिएबल myVar को दायरे के शीर्ष पर फहराया गया है लेकिन प्रारंभ में अपरिभाषित है, जो आपके कोड में भ्रम पैदा कर सकता है।

? हल करना:

• ? let या const का उपयोग करें: ये कीवर्ड var की तरह ही फहराए नहीं जाते हैं, जो इस समस्या को रोकने में मदद करता है।

? उदाहरण सुधार:

console.log(myLet);  // ReferenceError: myLet is not defined
let myLet = 10;
console.log(myLet);  // 10

? टिप्पणी: लेट का उपयोग करने से वेरिएबल को घोषित होने से पहले एक्सेस होने से रोका जा सकता है, जिससे भ्रम और संभावित बग कम हो जाते हैं।

2️⃣ फ़ंक्शन स्कोप बनाम ब्लॉक स्कोप: var ब्लॉक से लीक हो सकता है!

? स्पष्टीकरण:

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

? प्रमुख बिंदु:

• ? फ़ंक्शन स्कोप: var का दायरा निकटतम फ़ंक्शन तक होता है, भले ही इसे लूप या if स्टेटमेंट जैसे ब्लॉक के अंदर घोषित किया गया हो।
• ? वैरिएबल लीक करना: इससे वेरिएबल अनजाने में ब्लॉक से लीक हो सकते हैं, जिससे अप्रत्याशित व्यवहार हो सकता है।

? उदाहरण:

if (true) {
  var blockVar = "I’m accessible outside this block";
}
console.log(blockVar);  // "I’m accessible outside this block"

? टिप्पणी: हालांकि ब्लॉकवार को if ब्लॉक के अंदर घोषित किया गया था, यह अभी भी ब्लॉक के बाहर पहुंच योग्य है क्योंकि var फ़ंक्शन-स्कोप्ड है, ब्लॉक-स्कोप्ड नहीं।

? हल करना:

• ? लेट या कॉन्स्ट का उपयोग करें: ये कीवर्ड ब्लॉक-स्कोप्ड हैं, जिसका अर्थ है कि वे केवल उस ब्लॉक के भीतर ही पहुंच योग्य हैं जहां उन्हें परिभाषित किया गया है।

? उदाहरण सुधार:

if (true) {
  let blockLet = "I’m only accessible inside this block";
}
console.log(blockLet);  // ReferenceError: blockLet is not defined

? टिप्पणी: लेट या कॉन्स्ट का उपयोग यह सुनिश्चित करता है कि वेरिएबल अपने संबंधित ब्लॉक तक ही सीमित रहें, जिससे स्कोप लीकेज को रोका जा सके।

3️⃣ पुनर्घोषणा मुद्दे: var आपको एक ही चर को दो बार घोषित करने की सुविधा देता है!

? स्पष्टीकरण:

var के साथ, आप गलती से उसी वेरिएबल को उसी दायरे में पुनः घोषित कर सकते हैं, जो पिछले मान को अधिलेखित कर सकता है। इससे अनजाने बग पैदा हो सकते हैं, खासकर बड़े कोडबेस में जहां गलती से वेरिएबल नामों का पुन: उपयोग किया जा सकता है।

? प्रमुख बिंदु:

• ? वेरिएबल्स को पुनः घोषित करना: var आपको एक ही दायरे में एक वेरिएबल को फिर से घोषित करने की अनुमति देता है, संभावित रूप से मौजूदा मानों को ओवरराइट करता है।
• ? अनपेक्षित ओवरराइट: इससे ऐसे बग पैदा हो सकते हैं जिनका पता लगाना मुश्किल होता है, खासकर बड़े या जटिल कार्यों में।

? उदाहरण:

var name = "Alice";
var name = "Bob";  // No error, overwrites the previous value
console.log(name);  // "Bob"

? टिप्पणी: नाम की दूसरी घोषणा पहले वाले को अधिलेखित कर देती है, जिससे संभावित रूप से कोड में बग उत्पन्न हो जाते हैं।

? हल करना:

• ? let या const का उपयोग करें: ये कीवर्ड आपको उसी दायरे में वेरिएबल्स को पुनः घोषित करने से रोकते हैं, जिससे अनपेक्षित ओवरराइट का जोखिम कम हो जाता है।

? उदाहरण सुधार:

let name = "Alice";
let name = "Bob";  // SyntaxError: Identifier 'name' has already been declared

? टिप्पणी: लेट या कॉन्स्ट का उपयोग करने से आपको वेरिएबल्स को पुनः घोषित करने से बचने में मदद मिलती है और यह सुनिश्चित होता है कि आपका कोड पूर्वानुमानित बना रहे।

लूप्स में 4️⃣ संस्करण: एसिंक्रोनस कोड में बग की संभावना

? स्पष्टीकरण:

लूप में var का उपयोग करते समय, वेरिएबल का मान अप्रत्याशित तरीकों से बदल सकता है, खासकर एसिंक्रोनस कोड के साथ काम करते समय। चूंकि var फ़ंक्शन-स्कोप्ड है और ब्लॉक-स्कोप्ड नहीं है, एसिंक्रोनस कॉलबैक के अंदर पहुंचने पर लूप वैरिएबल अप्रत्याशित मान रख सकता है।

? प्रमुख बिंदु:

• ? लूप वेरिएबल्स: वेरिएबल इनसाइड लूप्स के साथ घोषित वेरिएबल्स लूप ब्लॉक तक ही सीमित नहीं हैं, जिससे बाद में एक्सेस करने पर संभावित बग हो सकते हैं।
• ⏳ एसिंक्रोनस मुद्दे: यह सेटटाइमआउट या वादों जैसे एसिंक्रोनस ऑपरेशंस में बग पैदा कर सकता है, जहां लूप वेरिएबल का अप्रत्याशित मान हो सकता है।

? उदाहरण:

for (var i = 0; i  console.log(i), 1000);  // Prints: 3, 3, 3 (unexpected)
}

? टिप्पणी: क्योंकि var ब्लॉक-स्कोप्ड नहीं है, लूप वेरिएबल i को सभी पुनरावृत्तियों में साझा किया जाता है, और इसका अंतिम मान (3) प्रत्येक सेटटाइमआउट कॉलबैक में उपयोग किया जाता है।

? हल करना:

• ⛓ लेट का उपयोग करें: लेट कीवर्ड ब्लॉक-स्कोप्ड है, यह सुनिश्चित करता है कि लूप के प्रत्येक पुनरावृत्ति को लूप वेरिएबल का अपना स्वतंत्र मान मिलता है।

? उदाहरण सुधार:

for (let i = 0; i  console.log(i), 1000);  // Prints: 0, 1, 2 (as expected)
}

? टिप्पणी: लेट का उपयोग करने से प्रत्येक पुनरावृत्ति के लिए i का एक नया उदाहरण बनता है, एसिंक्रोनस कॉलबैक समस्या को ठीक किया जाता है और यह सुनिश्चित किया जाता है कि सही मान मुद्रित हों।

5️⃣ संस्करण और समापन: भ्रम का एक स्रोत

? स्पष्टीकरण:

var के साथ संयुक्त होने पर क्लोजर अप्रत्याशित व्यवहार का कारण बन सकता है। चूँकि var फ़ंक्शन-स्कोप्ड है, इसलिए इसका मान उन तरीकों से बदल सकता है जिनकी अपेक्षा नहीं की जाती है जब कोई क्लोजर इसे कैप्चर करता है।

? प्रमुख बिंदु:

• ? जावास्क्रिप्ट में क्लोजर: क्लोजर एक ऐसा फ़ंक्शन है जो बाहरी फ़ंक्शन के निष्पादित होने के बाद भी अपने आसपास के दायरे को याद रखता है।
• ? साझा परिवर्तनीय मुद्दे: जब var का उपयोग क्लोजर के अंदर किया जाता है, तो कैप्चर किए गए वेरिएबल को सभी क्लोजर में साझा किया जा सकता है, जिससे अप्रत्याशित व्यवहार हो सकता है।

? उदाहरण:

function createFunctions() {
  var funcs = [];
  for (var i = 0; i 



? टिप्पणी: सभी क्लोजर समान i मान कैप्चर कर रहे हैं क्योंकि var फ़ंक्शन-स्कोप है, जिससे अप्रत्याशित परिणाम मिलते हैं।

? हल करना:

• ? लेट का उपयोग करें: लेट का उपयोग करके, प्रत्येक क्लोजर लूप वेरिएबल का एक नया उदाहरण कैप्चर करता है, जिससे समस्या हल हो जाती है।

? उदाहरण सुधार:

function createFunctions() {
  var funcs = [];
  for (let i = 0; i 



? टिप्पणी: लेट के साथ, प्रत्येक क्लोजर को i की अपनी प्रति मिल जाती है, जिससे समस्या का समाधान हो जाता है और यह सुनिश्चित हो जाता है कि अपेक्षित मान मुद्रित हो गए हैं।





  
  
  ? निष्कर्ष: var को अलविदा कहने का समय


हालांकि var जावास्क्रिप्ट में वेरिएबल घोषित करने का मूल तरीका था, इसमें कई कमियां हैं जो इसे आधुनिक जावास्क्रिप्ट विकास में एक खराब विकल्प बनाती हैं। लेट और कॉन्स्ट का परिचय बेहतर स्कोपिंग प्रदान करता है, बग के जोखिम को कम करता है, और आपके कोड को अधिक पूर्वानुमानित बनाता है। स्वच्छ और अधिक रखरखाव योग्य जावास्क्रिप्ट लिखने के लिए, अब var से आगे बढ़ने और Let और const को अपनाने का समय आ गया है।