javascript - हरण - हिंदी में जावास्क्रिप्ट परिचय




जावास्क्रिप्ट में चर के दायरे क्या है? (17)

आधुनिक जेएस, ईएस 6 +, ' const ' और ' let '

आपको अन्य सभी प्रमुख भाषाओं की तरह, आपके द्वारा बनाए गए प्रत्येक चर के लिए ब्लॉक स्कोपिंग का उपयोग करना चाहिए। var अप्रचलित है । यह आपके कोड को सुरक्षित और अधिक रखरखाव बनाता है।

95% मामलों के लिए const का इस्तेमाल किया जाना चाहिए। यह ऐसा करता है इसलिए परिवर्तनीय संदर्भ बदल नहीं सकता है। ऐरे, ऑब्जेक्ट, और डोम नोड गुण बदल सकते हैं और संभवतः const होना चाहिए।

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

ब्लॉक स्कोप का अर्थ है कि वेरिएबल केवल उन ब्रैकेट्स के भीतर उपलब्ध होगा जिनमें इसे घोषित किया गया है। यह आपके दायरे में बनाए गए अज्ञात कार्यों सहित आंतरिक क्षेत्रों में फैला हुआ है।

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


पुरानी स्कूल जावास्क्रिप्ट

पारंपरिक रूप से, जावास्क्रिप्ट में वास्तव में केवल दो प्रकार के दायरे होते हैं:

  1. वैश्विक दायरा : आवेदन की शुरुआत से वैरिएबल पूरे एप्लिकेशन में जाना जाता है (*)
  2. कार्यात्मक स्कोप : वेरिएबल्स फ़ंक्शन (*) की शुरुआत से, उनके द्वारा घोषित किए गए फ़ंक्शन के भीतर ज्ञात हैं

मैं इस पर विस्तार नहीं करूंगा, क्योंकि अंतर को समझाते हुए पहले से ही कई अन्य उत्तर हैं।

आधुनिक जावास्क्रिप्ट

सबसे हालिया जावास्क्रिप्ट चश्मे अब भी तीसरे दायरे की अनुमति देते हैं:

  1. ब्लॉक स्कोप : वैरिएबल उन ब्लॉक के भीतर ज्ञात हैं जिन्हें वे घोषित कर रहे हैं, जिस क्षण से उन्हें घोषित किया जाता है (**)

मैं ब्लॉक स्कोप चर कैसे बना सकता हूं?

पारंपरिक रूप से, आप इस तरह के अपने चर बनाते हैं:

var myVariable = "Some text";

ब्लॉक स्कोप चर इस तरह बनाए गए हैं:

let myVariable = "Some text";

तो कार्यात्मक दायरे और ब्लॉक गुंजाइश के बीच क्या अंतर है?

कार्यात्मक दायरे और ब्लॉक स्कोप के बीच अंतर को समझने के लिए, निम्न कोड पर विचार करें:

// 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 स्टेटमेंट का उपयोग कर सकते हैं, हालांकि आपका कोड प्रदर्शन के संबंध में इष्टतम लेकिन कुछ भी होने की संभावना है।

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

    आज, 23 फरवरी 2016, ये कुछ ब्राउज़र हैं जो या तो समर्थन नहीं करते let या केवल आंशिक समर्थन करते हैं:

    • इंटरनेट एक्सप्लोरर 10 और नीचे (कोई समर्थन नहीं)
    • फ़ायरफ़ॉक्स 43 और नीचे (कोई समर्थन नहीं)
    • सफारी 9 और नीचे (कोई समर्थन नहीं)
    • ओपेरा मिनी 8 और नीचे (कोई समर्थन नहीं)
    • एंड्रॉइड ब्राउज़र 4 और नीचे (कोई समर्थन नहीं)
    • ओपेरा 36 और नीचे (आंशिक समर्थन)
    • क्रोम 51 और नीचे (आंशिक समर्थन)

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

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

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

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


"जावास्क्रिप्ट 1.7" में (मोज़िला का जावास्क्रिप्ट का विस्तार) कोई भी बयान के साथ ब्लॉक-स्कोप चर घोषित कर सकता है:

 var a = 4;
 let (a = 3) {
   alert(a); // 3
 }
 alert(a);   // 4

1) एक वैश्विक दायरा, एक समारोह का दायरा है, और साथ में पकड़ और पकड़ने के लिए। चर के लिए सामान्य रूप से कोई 'ब्लॉक' स्तर का दायरा नहीं है - साथ और पकड़ बयान उनके ब्लॉक में नाम जोड़ते हैं।

2) वैश्विक दायरे के लिए सभी तरह से कार्यों द्वारा घोंसला घोंसला जाता है।

3) गुण प्रोटोटाइप श्रृंखला के माध्यम से हल करके हल कर रहे हैं। विवरण के साथ ब्लॉक के साथ परिभाषित शब्दावली क्षेत्र में वस्तु संपत्ति नाम लाता है।

संपादित करें: ECMAAScript 6 (सद्भावना) को समर्थन देने के लिए speced किया गया है, और मुझे पता है क्रोम एक 'सद्भाव' ध्वज की अनुमति देता है, तो शायद यह इसका समर्थन करता है ..

चलो ब्लॉक स्तर स्कोपिंग के लिए एक समर्थन होगा, लेकिन इसे करने के लिए आपको कीवर्ड का उपयोग करना होगा।

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

 //chrome (v8)

 var a = { 'test1':'test1val' }
 test1   // error not defined
 with (a) { var test1 = 'replaced' }
 test1   // undefined
 a       // a.test1 = 'replaced'

संपादित करें: स्पष्टीकरण उदाहरण:

test1 ब्लॉक के साथ scoped है, लेकिन a.test1 के लिए aliased है। 'Var test1' ऊपरी अक्षीय संदर्भ (फ़ंक्शन, या वैश्विक) में एक नया चर परीक्षण 1 बनाता है, जब तक कि यह एक की संपत्ति न हो - जो यह है।

ओह! 'साथ' का उपयोग करके सावधान रहें - जैसे वैर एक नोप है यदि चर पहले से ही फ़ंक्शन में परिभाषित किया गया है, तो यह ऑब्जेक्ट से आयात किए गए नामों के संबंध में एक नोप भी है! पहले से परिभाषित नाम पर थोड़ा सिर इसे अधिक सुरक्षित बना देगा। इस वजह से मैं व्यक्तिगत रूप से कभी भी इसका उपयोग नहीं करूंगा।


केवल दो प्रकार के जावास्क्रिप्ट स्कॉप्स हैं:

  • प्रत्येक विविध घोषणा का दायरा सबसे तत्काल संलग्न कार्य से जुड़ा हुआ है
  • यदि एक विविध घोषणा के लिए कोई संलग्न कार्य नहीं है, तो यह वैश्विक दायरा है

इसलिए, कार्यों के अलावा कोई भी ब्लॉक एक नया दायरा नहीं बनाता है। यह बताता है कि फॉर-लूप बाहरी स्कॉइड चर को ओवरराइट क्यों करते हैं:

var i = 10, v = 10;
for (var i = 0; i < 5; i++) { var v = 5; }
console.log(i, v);
// output 5 5

इसके बजाय कार्यों का उपयोग करना:

var i = 10, v = 10;
$.each([0, 1, 2, 3, 4], function(i) { var v = 5; });
console.log(i,v);
// output 10 10

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

जावास्क्रिप्ट स्कॉइंग के संदर्भ में आपको लगभग इतना ही पता होना चाहिए, सिवाय इसके कि:

  • केवल अपवाद चर के लिए नए दायरे को पेश करने / पकड़ने का प्रयास करें, अन्य चरों में नया दायरा नहीं है
  • स्पष्ट रूप से एक और अपवाद है, लेकिन क्लॉज के साथ इसका उपयोग अत्यधिक निराश ( https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/with )

तो आप जावास्क्रिप्ट स्कॉपिंग वास्तव में बेहद सरल हैं, यद्यपि हमेशा सहज नहीं है। कुछ चीजों के बारे में पता होना चाहिए:

  • विभिन्न घोषणाओं को दायरे के शीर्ष पर फहराया जाता है। इसका मतलब यह नहीं है कि विभिन्न घोषणाएं कहां होती हैं, कंपाइलर के लिए ऐसा लगता है जैसे var शीर्ष पर होता है
  • एक ही दायरे के भीतर कई var घोषणाएं संयुक्त हैं

तो यह कोड:

var i = 1;
function abc() {
  i = 2;
  var i = 3;
}
console.log(i);     // outputs 1

के बराबर है:

var i = 1;
function abc() {
  var i;     // var declaration moved to the top of the scope
  i = 2;
  i = 3;     // the assignment stays where it is
}
console.log(i);

यह काउंटर अंतर्ज्ञानी प्रतीत हो सकता है, लेकिन यह एक अनिवार्य भाषा डिजाइनर के परिप्रेक्ष्य से समझ में आता है।


कोड चलाओ। उम्मीद है कि यह स्कोपिंग के बारे में एक विचार देगा

Name = 'global data';
document.Name = 'current document data';
(function(window,document){
var Name = 'local data';
var myObj = {
    Name: 'object data',
    f: function(){
        alert(this.Name);
    }
};

myObj.newFun = function(){
    alert(this.Name);
}

function testFun(){
    alert("Window Scope : " + window.Name + 
          "\nLocal Scope : " + Name + 
          "\nObject Scope : " + this.Name + 
          "\nCurrent document Scope : " + document.Name
         );
}


testFun.call(myObj);
})(window,document);

जावास्क्रिप्ट कोड (वैश्विक कोड या फ़ंक्शंस) के प्रत्येक हिस्से में इसके साथ जुड़े एक स्कोप चेन है। यह स्कोप श्रृंखला ऑब्जेक्ट्स की एक सूची या श्रृंखला है जो उस कोड के लिए "दायरे में" चर को परिभाषित करती है। जब जावास्क्रिप्ट को एक चर x ( वैरिएबल रिज़ॉल्यूशन नामक एक प्रक्रिया) के मान को देखने की आवश्यकता होती है, तो यह श्रृंखला में पहली वस्तु को देखकर शुरू होती है। यदि उस ऑब्जेक्ट में x नाम की एक संपत्ति है, तो उस संपत्ति का मूल्य उपयोग किया जाता है। यदि पहली ऑब्जेक्ट में x नाम की कोई संपत्ति नहीं है, तो जावास्क्रिप्ट श्रृंखला में अगली ऑब्जेक्ट के साथ खोज जारी रखता है। यदि दूसरी ऑब्जेक्ट में x नाम की कोई संपत्ति नहीं है, तो खोज अगली ऑब्जेक्ट पर जाती है, और इसी तरह। यदि x स्कोप श्रृंखला में किसी भी वस्तु की संपत्ति नहीं है, तो x उस कोड के दायरे में नहीं है, और एक संदर्भ त्रुटि होती है। शीर्ष-स्तरीय जावास्क्रिप्ट कोड (यानी, कोड किसी भी फ़ंक्शन परिभाषाओं में शामिल नहीं है) में, स्कोप श्रृंखला में एक ऑब्जेक्ट, वैश्विक ऑब्जेक्ट होता है। एक गैर-नेस्टेड फ़ंक्शन में, स्कोप श्रृंखला में दो ऑब्जेक्ट होते हैं। पहला वह ऑब्जेक्ट है जो फ़ंक्शन के पैरामीटर और स्थानीय चर को परिभाषित करता है, और दूसरा वैश्विक वस्तु है। नेस्टेड फ़ंक्शन में, स्कोप चेन में तीन या अधिक ऑब्जेक्ट होते हैं। यह समझना महत्वपूर्ण है कि वस्तुओं की यह श्रृंखला कैसे बनाई जाती है। जब कोई फ़ंक्शन डिफिन्ड किया जाता है , तो यह प्रभावी रूप से स्कोप श्रृंखला को संग्रहीत करता है। जब वह फ़ंक्शन इनवॉक्ड किया जाता है , तो यह अपने स्थानीय चर को संग्रहीत करने के लिए एक नई ऑब्जेक्ट बनाता है, और उस नई ऑब्जेक्ट को संग्रहीत स्कोप श्रृंखला में जोड़ता है ताकि वह एक नई, लंबी श्रृंखला बन सके जो उस फ़ंक्शन आमंत्रण के दायरे को दर्शाती है। यह नेस्टेड फ़ंक्शंस के लिए अधिक दिलचस्प हो जाता है क्योंकि प्रत्येक बार बाहरी फ़ंक्शन कहलाता है, आंतरिक फ़ंक्शन को फिर से परिभाषित किया जाता है। Since the scope chain differs on each invocation of the outer function, the inner function will be subtly different each time it is defined—the code of the inner function will be identical on each invocation of the outer function, but the scope chain associated with that code will be different . This notion of a scope chain is crucial for understanding closures .


जावास्क्रिप्ट में केवल दो प्रकार का दायरा है:

  1. वैश्विक दायरा : वैश्विक खिड़की के स्तर के दायरे के अलावा कुछ भी नहीं है। यहां, पूरे आवेदन में परिवर्तनीय उपस्थिति।
  2. कार्यात्मक स्कोप : var कीवर्ड वाले फ़ंक्शन के भीतर घोषित वैरिएबल में कार्यात्मक दायरा है।

जब भी कोई फ़ंक्शन कहा जाता है, तो एक चरणीय स्कोप ऑब्जेक्ट बनाया जाता है (और स्कोप चेन में शामिल किया जाता है) जिसके बाद जावास्क्रिप्ट में चर होते हैं।

        a = "global";
         function outer(){ 
              b = "local";
              console.log(a+b); //"globallocal"
         }
outer();

स्कोप श्रृंखला ->

  1. खिड़की का स्तर - a और outer कार्य स्कोप श्रृंखला में शीर्ष स्तर पर हैं।
  2. जब बाहरी फ़ंक्शन को एक नई variable scope object (और स्कोप चेन में शामिल किया जाता है) कहा जाता है तो इसके अंदर परिवर्तनीय b साथ जोड़ा जाता है।

अब जब एक वैरिएबल a आवश्यकता होती है तो यह पहले निकटतम परिवर्तनीय दायरे के लिए खोज करता है और यदि चर वैरिएबल स्कोप श्रृंखला के अगले ऑब्जेक्ट में स्थानांतरित होता है तो यह चर नहीं है। इस मामले में विंडो स्तर है।


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

तो इस परिप्रेक्ष्य से, मुझे लगता है कि एक तस्वीर मदद करेगी जो मुझे काइल सिम्पसन द्वारा स्कोप्स और क्लोजर्स ईबुक में मिली है:

अपनी ईबुक से उद्धरण:

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

ध्यान देने योग्य बात यह है कि "पहला मैच मिलने के बाद स्कोप लुक-अप बंद हो जाता है"।

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


मुझे लगता है कि मैं सबसे अच्छा कर सकता हूं, आपको अध्ययन करने के लिए उदाहरणों का एक समूह प्रदान करता है। जावास्क्रिप्ट प्रोग्रामर व्यावहारिक रूप से रैंक किए जाते हैं कि वे कितनी अच्छी तरह समझते हैं। यह कभी-कभी काफी प्रतिद्वंद्वी हो सकता है।

  1. एक विश्व स्तर पर स्कॉप्ड चर

    // global scope
    var a = 1;
    
    function one() {
      alert(a); // alerts '1'
    }
    
  2. स्थानीय दायरा

    // global scope
    var a = 1;
    
    function two(a) {
      // local scope
      alert(a); // alerts the given argument, not the global value of '1'
    }
    
    // local scope again
    function three() {
      var a = 3;
      alert(a); // alerts '3'
    }
    
  3. इंटरमीडिएट : जावास्क्रिप्ट में ब्लॉक स्कोप जैसी कोई चीज़ नहीं (ES5; ES6 परिचय let )

    ए।

    var a = 1;
    
    function four() {
      if (true) {
        var a = 4;
      }
    
      alert(a); // alerts '4', not the global value of '1'
    }
    

    ख।

    var a = 1;
    
    function one() {
      if (true) {
        let a = 4;
      }
    
      alert(a); // alerts '1' because the 'let' keyword uses block scoping
    }
    
  4. इंटरमीडिएट : ऑब्जेक्ट गुण

    var a = 1;
    
    function Five() {
      this.a = 5;
    }
    
    alert(new Five().a); // alerts '5'
    
  5. उन्नत : बंद करो

    var a = 1;
    
    var six = (function() {
      var a = 6;
    
      return function() {
        // JavaScript "closure" means I have access to 'a' in here,
        // because it is defined in the function in which I was defined.
        alert(a); // alerts '6'
      };
    })();
    
  6. उन्नत : प्रोटोटाइप-आधारित स्कोप रिज़ॉल्यूशन

    var a = 1;
    
    function seven() {
      this.a = 7;
    }
    
    // [object].prototype.property loses to
    // [object].property in the lookup chain. For example...
    
    // Won't get reached, because 'a' is set in the constructor above.
    seven.prototype.a = -1;
    
    // Will get reached, even though 'b' is NOT set in the constructor.
    seven.prototype.b = 8;
    
    alert(new seven().a); // alerts '7'
    alert(new seven().b); // alerts '8'
    
  7. वैश्विक + स्थानीय : एक अतिरिक्त जटिल मामला

    var x = 5;
    
    (function () {
        console.log(x);
        var x = 10;
        console.log(x); 
    })();
    

    यह undefined और 5 और 10 बजाय 10 प्रिंट करेगा क्योंकि जावास्क्रिप्ट हमेशा दायरे के शीर्ष पर परिवर्तनीय घोषणाएं (प्रारंभिकरण नहीं) चलाता है, जिससे कोड बराबर होता है:

    var x = 5;
    
    (function () {
        var x;
        console.log(x);
        x = 10;
        console.log(x); 
    })();
    
  8. खंड-स्कोप्ड चर पकड़ो

    var e = 5;
    console.log(e);
    try {
        throw 6;
    } catch (e) {
        console.log(e);
    }
    console.log(e);
    

    यह 5 , 6 , 5 प्रिंट करेगा। कैच क्लॉज e अंदर वैश्विक और स्थानीय चर शामिल हैं। लेकिन यह विशेष दायरा केवल पकड़े गए चर के लिए है। यदि आप var f; लिखते हैं var f; कैच क्लॉज के अंदर, फिर यह वही है जैसा आपने कोशिश-पकड़ ब्लॉक से पहले या बाद में परिभाषित किया था।


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

इस सुविधा को आजमाएं:

यहां एक डेमो देखें:

यहां कोड देखें:

वर्तमान में यह सुविधा 16 नेस्टेड फ़ंक्शंस की गहराई के लिए समर्थन प्रदान करती है, लेकिन वर्तमान में वैश्विक चर रंग नहीं है।


यहां एक उदाहरण दिया गया है:

<script>

var globalVariable = 7; //==window.globalVariable

function aGlobal( param ) { //==window.aGlobal(); 
                            //param is only accessible in this function
  var scopedToFunction = {
    //can't be accessed outside of this function

    nested : 3 //accessible by: scopedToFunction.nested
  };

  anotherGlobal = {
    //global because there's no `var`
  }; 

}

</script>

आप बंद करने की जांच करना चाहते हैं, और निजी सदस्यों को बनाने के लिए उनका उपयोग कैसे करना चाहते हैं


ECMAScript 6 introduced the let and const keywords. These keywords can be used in place of the var keyword. Contrary to the var keyword, the let and const keywords support the declaration of local scope inside block statements.

var x = 10
let y = 10
const z = 10
{
  x = 20
  let y = 20
  const z = 20
  {
    x = 30
    // x is in the global scope because of the 'var' keyword
    let y = 30
    // y is in the local scope because of the 'let' keyword
    const z = 30
    // z is in the local scope because of the 'const' keyword
    console.log(x) // 30
    console.log(y) // 30
    console.log(z) // 30
  }
  console.log(x) // 30
  console.log(y) // 20
  console.log(z) // 20
}

console.log(x) // 30
console.log(y) // 10
console.log(z) // 10

Global: variable declared outside of a function

स्थानीय: एक फ़ंक्शन के अंदर घोषित घोषित, और केवल उस दायरे में ही कहा जा सकता है


In JavaScript there are two types of scope:

  • Local scope
  • Global scope

The Below function has a local scope variable carName . And this variable is not accessible from outside of the function.

function myFunction() {
    var carName = "Volvo";
    alert(carName);
    // code here can use carName
}

The Below Class has a Global scope variable carName . And this variable is accessible from everywhere in the class.

class {

    var carName = " Volvo";

    // code here can use carName

    function myFunction() {
        alert(carName);
        // code here can use carName 
    }
}

My understanding is that there are 3 scopes: global scope, available globally; local scope, available to an entire function regardless of blocks; and block scope, only available to the block, statement, or expression on which it was used. Global and local scope are indicated with the keyword 'var', either within a function or outside, and block scope is indicated with the keyword 'let'.

For those that believe there is only global and local scope, please explain why Mozilla would have an entire page describing the nuances of block scope in JS.

let


Try this curious example. In the example below if a were a numeric initialized at 0, you'd see 0 and then 1. Except a is an object and javascript will pass f1 a pointer of a rather than a copy of it. The result is that you get the same alert both times.

var a = new Date();
function f1(b)
{
    b.setDate(b.getDate()+1);
    alert(b.getDate());
}
f1(a);
alert(a.getDate());







scope