JavaScript में let बनाम var: गति और कोड के लिए क्या चुनें?

let vs var: दुनिया का युद्ध या JavaScript का विकास?

क्या आपने कभी JavaScript में कोड लिखा है और सोचा है: "यह वेरिएबल इतना अजीब व्यवहार क्यों कर रहा है?" या इससे भी बुरा, क्या आपको कोई बग मिला जो var को let से बदलने पर गायब हो जाता है? क्लब में आपका स्वागत है। Stack Overflow पर "What is the difference between 'let' and 'var'?" प्रश्न सैकड़ों हज़ारों बार देखा जाता है, यह कोई संयोग नहीं है - यह शुरुआती और अनुभवी डेवलपर्स के लिए सबसे आम जालों में से एक है।

आज हम केवल अंतरों को सूचीबद्ध नहीं करेंगे। हम हुड के नीचे देखेंगे: समझेंगे कि let और var आपके कोड के प्रदर्शन, आधुनिक इंजनों (V8, SpiderMonkey) में अनुकूलन को कैसे प्रभावित करते हैं, और क्यों उनके बीच चुनाव केवल शैली का नहीं, बल्कि दक्षता का भी सवाल है। तैयार हो जाइए, यह गर्म होने वाला है।

मुख्य बातें संक्षेप में: स्कोप और होइस्टिंग

प्रदर्शन के बारे में बात करने से पहले, आइए बुनियादी बातों को याद करें। var और let में तीन प्रमुख अंतर हैं जो सब कुछ बदल देते हैं।

1. स्कोप (Scope)

\n
• var - इसमें फंक्शनल स्कोप होता है। यदि वेरिएबल किसी फंक्शन के अंदर घोषित किया गया है, तो वह पूरे फंक्शन में दिखाई देता है। यदि बाहर है, तो वह ग्लोबल है।
\n
• let - इसमें ब्लॉक स्कोप होता है। यह केवल निकटतम घुंघराले ब्रेसेस {} (लूप, कंडीशन, ब्लॉक) के अंदर रहता है।
\n

// var के साथ उदाहरण\nif (true) {\n    var x = 10;\n}\nconsole.log(x); // 10 — वेरिएबल ब्लॉक से "बाहर निकल गया"\n\n// let के साथ उदाहरण\nif (true) {\n    let y = 20;\n}\nconsole.log(y); // ReferenceError: y परिभाषित नहीं है\n

2. होइस्टिंग (Hoisting) और टेम्पोरल डेड ज़ोन (TDZ)

दोनों वेरिएबल "उठाए" (hoisted) जाते हैं, लेकिन अलग-अलग व्यवहार करते हैं।

\n
• var: घोषणा को स्कोप के शीर्ष पर उठाया जाता है और undefined मान से प्रारंभ किया जाता है। आप घोषणा से पहले वेरिएबल तक पहुँच सकते हैं (लेकिन आपको undefined मिलेगा)।
\n
• let: घोषणा को उठाया जाता है, लेकिन प्रारंभ नहीं किया जाता। वास्तविक घोषणा के क्षण तक, वेरिएबल "टेम्पोरल डेड ज़ोन" (Temporal Dead Zone) में होता है। इस तक कोई भी पहुँच ReferenceError उत्पन्न करती है।
\n

// var — "सुरक्षित" undefined\nconsole.log(a); // undefined\nvar a = 5;\n\n// let — TDZ में त्रुटि\nconsole.log(b); // ReferenceError: प्रारंभ से पहले 'b' तक नहीं पहुँचा जा सकता\nlet b = 10;\n

3. पुनः घोषणा

\n
• var - एक ही स्कोप में जितनी बार चाहें पुनः घोषित किया जा सकता है। कोई त्रुटि नहीं होगी।
\n
• let - एक ही स्कोप में पुनः घोषणा SyntaxError उत्पन्न करेगी।
\n

var z = 1;\nvar z = 2; // ठीक है\n\nlet w = 1;\nlet w = 2; // SyntaxError: पहचानकर्ता 'w' पहले ही घोषित किया जा चुका है\n

अब मुख्य बात पर: प्रदर्शन और अनुकूलन

बहुत से लोग सोचते हैं: "चूँकि let नया मानक है, तो यह var से धीमा होगा?" या इसके विपरीत: "let बेहतर है, तो यह तेज़ होगा"। सच्चाई, हमेशा की तरह, बीच में है और संदर्भ पर निर्भर करती है।

इंजन वेरिएबल को कैसे अनुकूलित करते हैं

आधुनिक JavaScript इंजन (Chrome/Node.js में V8, Firefox में SpiderMonkey) JIT-कंपाइलर का उपयोग करके कोड को मशीन कोड में संकलित करते हैं। वे अनुकूलन के लिए ह्यूरिस्टिक्स का उपयोग करते हैं।

\n
• var: फंक्शनल स्कोप और आकस्मिक पुनर्परिभाषा की संभावना के कारण, इंजन के लिए वेरिएबल के प्रकार के बारे में अनुमान लगाना कठिन होता है। यह अक्सर "भारी" VariableObject ऑब्जेक्ट बनाता है जो वेरिएबल को डायनामिक मेमोरी में संग्रहीत करता है।
\n
• let: ब्लॉक स्कोप और पुनः घोषणा पर प्रतिबंध इंजन को बेहतर अनुमान लगाने की अनुमति देता है। यह वेरिएबल को रजिस्टरों या स्टैक पर संग्रहीत कर सकता है, जो तेज़ है।
\n