javascript जावास्क्रिप्ट में एक चर घोषित करने के लिए "let" और "var" का उपयोग करने के बीच क्या अंतर है?



13 Answers

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

DEMO

for(var i = 1; i < 6; i++) {
  document.getElementById('my-element' + i)
    .addEventListener('click', function() { alert(i) })
}

उपरोक्त कोड क्लासिक जावास्क्रिप्ट बंद करने की समस्या का प्रदर्शन करता है। i वैरिएबल को संदर्भ i के वास्तविक मूल्य की बजाय क्लिक हैंडलर क्लोजर में संग्रहीत किया जा रहा है।

प्रत्येक एकल क्लिक हैंडलर एक ही ऑब्जेक्ट को संदर्भित करेगा क्योंकि केवल एक काउंटर ऑब्जेक्ट है जिसमें 6 है, इसलिए आपको प्रत्येक क्लिक पर छः मिलते हैं।

सामान्य कामकाज इसे किसी अज्ञात फ़ंक्शन में लपेटना है और i तर्क के रूप में पास करना है। नीचे दिए गए कोड में दिखाए गए अनुसार बदले में बदले में ऐसे मुद्दों को भी टाला जा सकता है।

DEMO (क्रोम और फ़ायरफ़ॉक्स में परीक्षण 50)

'use strict';

for(let i = 1; i < 6; i++) {
  document.getElementById('my-element' + i)
    .addEventListener('click', function() { alert(i) })
}
javascript scope ecmascript-6 var let

ईसीएमएस्क्रिप्ट 6 ने let स्टेटमेंट पेश किया । मैंने इसे "स्थानीय" चर के रूप में वर्णित सुना है, लेकिन मुझे अभी भी यह सुनिश्चित नहीं है कि यह विभिन्न कीवर्ड से अलग तरीके से कैसे व्यवहार करता है।

क्या अंतर हैं? var पर इस्तेमाल कब किया जाना चाहिए?




let और var बीच क्या अंतर है?

  • एक var कथन का उपयोग करके परिभाषित एक चर को फ़ंक्शन की शुरुआत से परिभाषित किया गया फ़ंक्शन में जाना जाता है। (*)
  • एक let स्टेटमेंट का उपयोग करके परिभाषित एक चर केवल उस ब्लॉक में जाना जाता है जिसे परिभाषित किया गया है, जिस क्षण से इसे परिभाषित किया गया है। (**)

अंतर को समझने के लिए, निम्न कोड पर विचार करें:

// i IS NOT known here
// j IS NOT known here
// k IS known here, but undefined
// l IS NOT known here

function loop(arr) {
    // i IS known here, but undefined
    // j IS NOT known here
    // k IS known here, but has a value only the second time loop is called
    // l IS NOT known here

    for( var i = 0; i < arr.length; i++ ) {
        // i IS known here, and has a value
        // j IS NOT known here
        // k IS known here, but has a value only the second time loop is called
        // l IS NOT known here
    };

    // i IS known here, and has a value
    // j IS NOT known here
    // k IS known here, but has a value only the second time loop is called
    // l IS NOT known here

    for( let j = 0; j < arr.length; j++ ) {
        // i IS known here, and has a value
        // j IS known here, and has a value
        // k IS known here, but has a value only the second time loop is called
        // l IS NOT known here
    };

    // i IS known here, and has a value
    // j IS NOT known here
    // k IS known here, but has a value only the second time loop is called
    // l IS NOT known here
}

loop([1,2,3,4]);

for( var k = 0; k < arr.length; k++ ) {
    // i IS NOT known here
    // j IS NOT known here
    // k IS known here, and has a value
    // l IS NOT known here
};

for( let l = 0; l < arr.length; l++ ) {
    // i IS NOT known here
    // j IS NOT known here
    // k IS known here, and has a value
    // l IS known here, and has a value
};

loop([1,2,3,4]);

// i IS NOT known here
// j IS NOT known here
// k IS known here, and has a value
// l IS NOT known here

यहां, हम देख सकते हैं कि हमारे चर j को केवल लूप के लिए पहले जाना जाता है, लेकिन पहले और बाद में नहीं। फिर भी, हमारे चर i पूरे समारोह में जाना जाता है।

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

क्या आज उपयोग करना सुरक्षित है?

कुछ लोग तर्क देंगे कि भविष्य में हम केवल बयानों का उपयोग करेंगे और वे कथन कथन अप्रचलित हो जाएंगे। जावास्क्रिप्ट गुरु काइल सिम्पसन ने एक बहुत ही विस्तृत लेख लिखा कि ऐसा क्यों नहीं है

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

  • यदि आप सर्वर-साइड जावास्क्रिप्ट कोड ( Node.js ) लिख रहे हैं, तो आप सुरक्षित रूप से let स्टेटमेंट का उपयोग कर सकते हैं।

  • यदि आप क्लाइंट-साइड जावास्क्रिप्ट कोड लिख रहे हैं और एक ट्रांस्सेलर (जैसे ट्रेसेर) का उपयोग करते हैं, तो आप सुरक्षित रूप से let स्टेटमेंट का उपयोग कर सकते हैं, हालांकि आपका कोड प्रदर्शन के संबंध में इष्टतम लेकिन कुछ भी होने की संभावना है।

  • यदि आप क्लाइंट-साइड जावास्क्रिप्ट कोड लिख रहे हैं और एक ट्रांसलेटर का उपयोग नहीं करते हैं, तो आपको ब्राउज़र समर्थन पर विचार करने की आवश्यकता है।

आज, 8 जून 2018, अभी भी कुछ ब्राउज़र हैं जो समर्थन नहीं करते let !

ब्राउज़र समर्थन का ट्रैक कैसे रखें

इस उत्तर को पढ़ने के समय कौन से ब्राउज़र let स्टेटमेंट का समर्थन करते हैं, इसके बारे में एक अद्यतित अवलोकन के लिए, देखें कि Can I Use पृष्ठ का Can I Use

(*) वैश्विक स्तर पर और कार्यात्मक रूप से स्कॉप्ड चर प्रारंभ किए जा सकते हैं और घोषित किए जाने से पहले उपयोग किए जा सकते हैं क्योंकि जावास्क्रिप्ट चर को hoisted इसका मतलब यह है कि घोषणाएं हमेशा दायरे के शीर्ष पर बहुत अधिक होती हैं।

(**) ब्लॉक स्कॉप्ड वेरिएबल नहीं फंस गए हैं




let

ब्लॉक दायरा

let कीवर्ड का उपयोग करके घोषित वैरिएबल ब्लॉक-स्कोप्ड हैं, जिसका अर्थ है कि वे केवल उस ब्लॉक में उपलब्ध हैं जिसमें उन्हें घोषित किया गया था।

शीर्ष स्तर पर (एक समारोह के बाहर)

शीर्ष स्तर पर, वैरिएबल का उपयोग करके घोषित किया गया है कि वैश्विक वस्तु पर गुण न बनाएं।

var globalVariable = 42;
let blockScopedVariable = 43;

console.log(globalVariable); // 42
console.log(blockScopedVariable); // 43

console.log(this.globalVariable); // 42
console.log(this.blockScopedVariable); // undefined

एक समारोह के अंदर

एक समारोह के अंदर (लेकिन एक ब्लॉक के बाहर), let var के समान दायरा है।

(() => {
  var functionScopedVariable = 42;
  let blockScopedVariable = 43;

  console.log(functionScopedVariable); // 42
  console.log(blockScopedVariable); // 43
})();

console.log(functionScopedVariable); // ReferenceError: functionScopedVariable is not defined
console.log(blockScopedVariable); // ReferenceError: blockScopedVariable is not defined

एक ब्लॉक के अंदर

किसी ब्लॉक के अंदर let का उपयोग करके घोषित वैरिएबल को उस ब्लॉक के बाहर एक्सेस नहीं किया जा सकता है।

{
  var globalVariable = 42;
  let blockScopedVariable = 43;
  console.log(globalVariable); // 42
  console.log(blockScopedVariable); // 43
}

console.log(globalVariable); // 42
console.log(blockScopedVariable); // ReferenceError: blockScopedVariable is not defined

एक पाश के अंदर

लूप इन लूप के साथ घोषित वैरिएबल को केवल उस लूप के अंदर संदर्भित किया जा सकता है।

for (var i = 0; i < 3; i++) {
  var j = i * 2;
}
console.log(i); // 3
console.log(j); // 4

for (let k = 0; k < 3; k++) {
  let l = k * 2;
}
console.log(typeof k); // undefined
console.log(typeof l); // undefined
// Trying to do console.log(k) or console.log(l) here would throw a ReferenceError.

बंद के साथ लूप्स

यदि आप लूप में var बजाय उपयोग let , तो प्रत्येक पुनरावृत्ति के साथ आपको एक नया चर मिलता है। इसका मतलब है कि आप सुरक्षित रूप से एक लूप के अंदर बंद करने का उपयोग कर सकते हैं।

// Logs 3 thrice, not what we meant.
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}

// Logs 0, 1 and 2, as expected.
for (let j = 0; j < 3; j++) {
  setTimeout(() => console.log(j), 0);
}

अस्थायी मृत क्षेत्र

अस्थायी मृत क्षेत्र की वजह से, घोषित करने से पहले घोषित चर को एक्सेस नहीं किया जा सकता है। ऐसा करने का प्रयास करने से एक त्रुटि फेंकता है।

console.log(noTDZ); // undefined
var noTDZ = 43;
console.log(hasTDZ); // ReferenceError: hasTDZ is not defined
let hasTDZ = 42;

कोई पुन: घोषणा नहीं

आप let का उपयोग कर एक ही चर कई बार घोषित नहीं कर सकते हैं। आप वही पहचानकर्ता के रूप में एक वैरिएबल घोषित कर सकते हैं जो एक और वैरिएबल के रूप में घोषित किया गया था जिसे var का उपयोग करके घोषित किया गया था।

var a;
var a; // Works fine.

let b;
let b; // SyntaxError: Identifier 'b' has already been declared

var c;
let c; // SyntaxError: Identifier 'c' has already been declared

const

कॉन्स को ब्लॉक-स्कोप्ड के समान ही है और टीडीजेड है। हालांकि, दो चीजें अलग हैं।

कोई पुनः आवंटन नहीं

कास्ट का उपयोग कर घोषित वैरिएबल फिर से असाइन नहीं किया जा सकता है।

const a = 42;
a = 43; // TypeError: Assignment to constant variable.

ध्यान दें कि इसका मतलब यह नहीं है कि मूल्य अपरिवर्तनीय है। इसकी संपत्तियों को अभी भी बदला जा सकता है।

const obj = {};
obj.a = 42;
console.log(obj.a); // 42

यदि आप एक अपरिवर्तनीय वस्तु चाहते हैं, तो आपको ऑब्जेक्ट.फ्रीज़ Object.freeze() उपयोग करना चाहिए।

प्रारंभकर्ता की आवश्यकता है

const का उपयोग करके एक चर घोषित करते समय आपको हमेशा एक मान निर्दिष्ट करना होगा।

const a; // SyntaxError: Missing initializer in const declaration



यहां दोनों के बीच अंतर के लिए एक उदाहरण दिया गया है (समर्थन क्रोम के लिए अभी शुरू हुआ):

जैसा कि आप देख सकते हैं कि var j चर के लिए अभी भी लूप स्कोप (ब्लॉक स्कोप) के बाहर एक मान है, लेकिन let i वैरिएबल लूप स्कोप के बाहर अपरिभाषित है।

"use strict";
console.log("var:");
for (var j = 0; j < 2; j++) {
  console.log(j);
}

console.log(j);

console.log("let:");
for (let i = 0; i < 2; i++) {
  console.log(i);
}

console.log(i);




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

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

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

function varTest() {
  var x = 1;
  if (true) {
    var x = 2;  // same variable!
    console.log(x);  // 2
  }
  console.log(x);  // 2
}

function letTest() {
  let x = 1;
  if (true) {
    let x = 2;  // different variable
    console.log(x);  // 2
  }
  console.log(x);  // 1
}`

कार्यक्रमों और कार्यों के शीर्ष स्तर पर, var के विपरीत, वैश्विक वस्तु पर कोई संपत्ति नहीं बनाते हैं। उदाहरण के लिए:

var x = 'global';
let y = 'global';
console.log(this.x); // "global"
console.log(this.y); // undefined

जब किसी ब्लॉक के अंदर उपयोग किया जाता है, तो उस ब्लॉक पर चर के दायरे को सीमित करने दें। Var के बीच का अंतर नोट करें जिसका दायरा उस समारोह के अंदर है जहां इसे घोषित किया गया है।

var a = 1;
var b = 2;

if (a === 1) {
  var a = 11; // the scope is global
  let b = 22; // the scope is inside the if-block

  console.log(a);  // 11
  console.log(b);  // 22
} 

console.log(a); // 11
console.log(b); // 2

इसके अलावा यह ईसीएमए 6 फीचर को भी न भूलें, इसलिए यह अभी तक पूरी तरह से समर्थित नहीं है, इसलिए बैबेल इत्यादि का उपयोग करके ईसीएमए 5 पर इसे हमेशा बेहतर बना दिया जाता है ... बेबेल वेबसाइट पर जाने के बारे में अधिक जानकारी के लिए




अंतर प्रत्येक के साथ घोषित चर के scope में है।

व्यावहारिक रूप से, दायरे में अंतर के कई उपयोगी परिणाम हैं:

  1. letचर केवल अपने निकटतम संलग्न ब्लॉक ( { ... }) में दिखाई दे रहे हैं ।
  2. letवैरिएबल केवल कोड की लाइनों में प्रयोग योग्य होते हैं जो परिवर्तनीय घोषित होने के बाद होते हैं (भले ही वे फेंक रहे हों !)।
  3. letचर varया बाद में पुनर्विक्रय नहीं किया जा सकता है let
  4. वैश्विक letचर में वैश्विक चर जोड़े नहीं गए हैं window
  5. letचर के साथ चर का उपयोग करना आसान है (वे दौड़ की स्थिति का कारण नहीं बनाते हैं )।

letचर की दृश्यता को कम करके लगाए गए प्रतिबंध और अप्रत्याशित नाम टकरावों की संभावना में वृद्धि की संभावना बढ़ जाएगी। यह उनकी reachability (अप्रयुक्त स्मृति को पुनः प्राप्त करने में सहायता) सहित चर के बारे में ट्रैक करना और कारण बनाना आसान बनाता है ।

नतीजतन, letबड़े कार्यक्रमों में उपयोग किए जाने पर या जब स्वतंत्र रूप से विकसित ढांचे को नए और अप्रत्याशित तरीके से जोड़ा जाता है तो वेरिएबल्स समस्याएं पैदा करने की संभावना कम होती है।

varयदि आप सुनिश्चित हैं कि आप लूप (# 5) में बंद होने या अपने कोड (# 4) में बाहरी रूप से दिखाई देने वाले वैश्विक चर घोषित करने के लिए एकल बाध्यकारी प्रभाव चाहते हैं तो भी उपयोगी हो सकता है। ट्रांसपोर्टर स्पेस से बाहर और कोर भाषा में माइग्रेट varहोने पर निर्यात के लिए उपयोग की जा सकती है export

उदाहरण

1. निकटतम संलग्न ब्लॉक के बाहर कोई उपयोग नहीं: कोड का यह ब्लॉक संदर्भ त्रुटि फेंक देगा क्योंकि दूसरा उपयोग xब्लॉक के बाहर होता है जहां इसे घोषित किया जाता है let:

{
    let x = 1;
}
console.log(`x is ${x}`);  // ReferenceError during parsing: "x is not defined".

इसके विपरीत, varकाम के साथ एक ही उदाहरण ।

2. घोषणा से पहले कोई उपयोग नहीं:
कोड के इस ब्लॉक को कोड ReferenceErrorचलाने से पहले फेंक दिया जाएगा क्योंकि xइसे घोषित करने से पहले उपयोग किया जाता है:

{
    x = x + 1;  // ReferenceError during parsing: "x is not defined".
    let x;
    console.log(`x is ${x}`);  // Never runs.
}

इसके विपरीत, varकिसी भी अपवाद फेंकने के बिना पारदर्शी और रन के साथ एक ही उदाहरण ।

3. कोई पुनर्विक्रय नहीं: निम्न कोड दर्शाता है कि letबाद में घोषित एक चर को फिर से नहीं देखा जा सकता है:

let x = 1;
let x = 2;  // SyntaxError: Identifier 'x' has already been declared

4. ग्लोबल्स से जुड़ा नहीं है window:

var button = "I cause accidents because my name is too common.";
let link = "Though my name is common, I am harder to access from other JS files.";
console.log(link);  // OK
console.log(window.link);  // undefined (GOOD!)
console.log(window.button);  // OK

5. बंद करने के साथ आसान उपयोग: घोषित वैरिएबल varलूप के अंदर बंद होने के साथ अच्छी तरह से काम नहीं करते हैं। यहां एक साधारण लूप है जो वैरिएबल के मानों के अनुक्रम को आउटपुट करता है जो परिवर्तनीय iसमय पर अलग-अलग बिंदुओं पर है:

for (let i = 0; i < 5; i++) {
    console.log(`i is ${i}`), 125/*ms*/);
}

विशेष रूप से, यह आउटपुट:

i is 0
i is 1
i is 2
i is 3
i is 4

जावास्क्रिप्ट में हम अक्सर जब बनाए जाते हैं, तब से वे काफी बाद में चर का उपयोग करते हैं। जब हम आउटपुट को बंद करने के साथ आउटपुट में देरी करके इसका प्रदर्शन करते हैं setTimeout:

for (let i = 0; i < 5; i++) {
    setTimeout(_ => console.log(`i is ${i}`), 125/*ms*/);
}

... जब तक हम चिपके रहते हैं तब तक आउटपुट अपरिवर्तित रहता है let। इसके विपरीत, अगर हमने var iइसके बजाय उपयोग किया था :

for (var i = 0; i < 5; i++) {
    setTimeout(_ => console.log(`i is ${i}`), 125/*ms*/);
}

... लूप अप्रत्याशित रूप से "मैं 5" पांच बार आउटपुट करता हूं:

i is 5
i is 5
i is 5
i is 5
i is 5



let दिलचस्प है, क्योंकि यह हमें ऐसा कुछ करने की अनुमति देता है:

(() => {
    var count = 0;

    for (let i = 0; i < 2; ++i) {
        for (let i = 0; i < 2; ++i) {
            for (let i = 0; i < 2; ++i) {
                console.log(count++);
            }
        }
    }
})();

[0, 7] गिनती के परिणाम।

जहाँ तक

(() => {
    var count = 0;

    for (var i = 0; i < 2; ++i) {
        for (var i = 0; i < 2; ++i) {
            for (var i = 0; i < 2; ++i) {
                console.log(count++);
            }
        }
    }
})();

केवल मायने रखता है [0, 1]।




var वैश्विक दायरा (उछाल-सक्षम) चर है।

letऔर constब्लॉक गुंजाइश है।

test.js

{
    let l = 'let';
    const c = 'const';
    var v = 'var';
    v2 = 'var 2';
}

console.log(v, this.v);
console.log(v2, this.v2);
console.log(l); // ReferenceError: l is not defined
console.log(c); // ReferenceError: c is not defined




यदि मैं चश्मे को सही ढंग से पढ़ता हूं तो let शुक्रिया को केवल निजी सदस्यों को अनुकरण करने के लिए उपयोग किए जाने वाले स्वयं के आविष्कार कार्यों से बचने के लिए लीवरेज किया जा सकता है - एक लोकप्रिय डिजाइन पैटर्न जो कोड पठनीयता को कम करता है, डीबगिंग को जटिल करता है, जो वास्तविक कोड सुरक्षा या अन्य लाभ नहीं जोड़ता है - सिवाय किसी को संतुष्ट करने के अलावा अर्थशास्त्र के लिए इच्छा, तो इसका उपयोग बंद करो। / शेख़ी

var SomeConstructor;

{
    let privateScope = {};

    SomeConstructor = function SomeConstructor () {
        this.someProperty = "foo";
        privateScope.hiddenProperty = "bar";
    }

    SomeConstructor.prototype.showPublic = function () {
        console.log(this.someProperty); // foo
    }

    SomeConstructor.prototype.showPrivate = function () {
        console.log(privateScope.hiddenProperty); // bar
    }

}

var myInstance = new SomeConstructor();

myInstance.showPublic();
myInstance.showPrivate();

console.log(privateScope.hiddenProperty); // error

'देखें निजी इंटरफेस की नकल '




उपयोग करते समय let

letकीवर्ड जो कुछ भी ब्लॉक (आमतौर पर एक के दायरे को चर घोषणा देता { .. }जोड़ी) उसमें शामिल है। दूसरे शब्दों में, letपरोक्ष अपनी चर घोषणा के लिए किसी भी ब्लॉक की गुंजाइश hijacks।

letwindowऑब्जेक्ट में चर को एक्सेस नहीं किया जा सकता है क्योंकि उन्हें वैश्विक रूप से एक्सेस नहीं किया जा सकता है।

function a(){
    { // this is the Max Scope for let variable
        let x = 12;
    }
    console.log(x);
}
a(); // Uncaught ReferenceError: x is not defined

उपयोग करते समय var

var और ES5 में चर के कार्यों में स्कोप हैं जिसका अर्थ है कि वेरिएबल फ़ंक्शन के भीतर मान्य हैं और फ़ंक्शन के बाहर नहीं हैं।

varwindowऑब्जेक्ट में चर का उपयोग किया जा सकता है क्योंकि उन्हें वैश्विक रूप से एक्सेस नहीं किया जा सकता है।

function a(){ // this is the Max Scope for var variable
    { 
        var x = 12;
    }
    console.log(x);
}
a(); // 12

यदि आप और जानना चाहते हैं तो नीचे पढ़ना जारी रखें

दायरे पर सबसे प्रसिद्ध साक्षात्कार प्रश्नों में से एक भी सटीक उपयोग letऔर varनीचे के रूप में पर्याप्त हो सकता है ;

उपयोग करते समय let

for (let i = 0; i < 10 ; i++) {
    setTimeout(
        function a() {
            console.log(i); //print 0 to 9, that is literally AWW!!!
        }, 
        100 * i);
}

इसका कारण यह है कि, जब letप्रत्येक लूप पुनरावृत्ति के लिए उपयोग किया जाता है तो वेरिएबल स्कॉप्ड होता है और इसकी अपनी प्रतिलिपि होती है।

उपयोग करते समय var

for (var i = 0; i < 10 ; i++) {
    setTimeout(
        function a() {
            console.log(i); //print 10 times 10
        }, 
        100 * i);
}

इसका कारण यह है कि जब varप्रत्येक लूप पुनरावृत्ति के लिए उपयोग किया जाता है तो वेरिएबल स्कॉप्ड होता है और प्रतिलिपि साझा की जाती है।




पहले जावास्क्रिप्ट में केवल दो स्कोप थे, यानी कार्यात्मक और वैश्विक। 'के साथ let' कीवर्ड जावास्क्रिप्ट अब शुरू की है block-levelचर।

'लेट' कीवर्ड की पूरी समझ रखने के लिए, ES6: जावास्क्रिप्ट में परिवर्तनीय घोषित करने के लिए कीवर्ड 'चलो' मदद करेगा।




यह आलेख स्पष्ट रूप से var, let और const के बीच के अंतर को परिभाषित करता है

const एक संकेत है कि पहचानकर्ता को फिर से सौंप दिया नहीं जाएगा।

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

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

https://medium.com/javascript-scene/javascript-es6-var-let-or-const-ba58b8dcde75#.esmkpbg9b




ईसीएमएस्क्रिप्ट 6 ने "चलो" के अलावा "कॉन्स्ट" अन्य चर को घोषित करने के लिए एक और कीवर्ड जोड़ा।

"Var" पर "let" और "const" के परिचय का प्राथमिक लक्ष्य पारंपरिक शब्दावली स्कोपिंग के बजाय ब्लॉक स्कोपिंग होना है। यह आलेख "var" और "let" के बीच बहुत संक्षिप्त अंतर बताता है और इसमें "कॉन्स्ट" पर चर्चा भी शामिल है




Related