जावास्क्रिप्ट: चर स्कोप। कार्य क्षेत्र में परिवर्तनीय गुंजाइश Js वैश्विक चर

हैलो! आज हम चर के दायरे के बारे में बात करेंगे (एक चर क्या है) पढ़ें। तथ्य यह है कि जब आप किसी फ़ंक्शन में एक वैरिएबल बनाते हैं और उसका नाम फंक्शन के बाहर एक वैरिएबल के नाम के साथ मेल खाता है, तो वैरिएबल के ग्लोबल और लोकल स्कोप से जुड़ी कई दिलचस्प स्थितियां हो सकती हैं।

यह इस बात के साथ है कि हम इस पाठ को समझेंगे।

वैश्विक चर

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

वार a \u003d 6; // ग्लोबल वेरिएबल फंक्शन डबल () (रिटर्न अलर्ट (ए * ए; // ग्लोबल वेरिएबल का उपयोग करके) डबल ();

उदाहरण एक वैश्विक चर घोषित करता है, जिसे मान दिया जाता है 6. फ़ंक्शन में, हम इस चर तक पहुंच सकते हैं और इससे भी अधिक, इसके मूल्य को बदल सकते हैं और यह मान हर जगह बदल जाएगा।

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

वार a \u003d 6; फंक्शन डबल () (a \u003d 5; // फंक्शन रिटर्न अलर्ट में ग्लोबल वैरिएबल का मान बदलें (a * a);) double (a); // फ़ंक्शन दस्तावेज़ को कॉल करें। राइट करें (ए); // वैश्विक चर का मान

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

स्थानीय चर।

जब आप किसी फ़ंक्शन में एक चर घोषित करते हैं, तो यह स्थानीय हो जाता है और इसे केवल फ़ंक्शन के भीतर से एक्सेस किया जा सकता है। यह ध्यान दिया जाना चाहिए कि कथनों की अगर / और, के लिए, जबकि ... चर के दायरे को प्रभावित नहीं करते हैं।

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

फंक्शन डबल () (var a \u003d 6; रिटर्न अलर्ट (a * a); double) (); document.write (a); // एक स्थानीय चर का उपयोग करने की कोशिश कर रहा है

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

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

वार a \u003d 7; फ़ंक्शन डबल () (var a \u003d 6; रिटर्न अलर्ट (a * a); document.write (a);

जैसा कि आप यहां देख सकते हैं, फ़ंक्शन में, यह ऐसा है जैसे कि एक और चर बनाया जाता है, इस तथ्य के बावजूद कि इसका नाम वैश्विक एक के साथ मेल खाता है और यह स्थानीय चर है जो फ़ंक्शन में उपलब्ध होगा; यह वैश्विक एक को अधिलेखित करने में सक्षम नहीं होगा, जैसा कि इस उदाहरण से पता चलता है।

इस सब से क्या निष्कर्ष निकाला जा सकता है? यही कारण है कि फ़ंक्शन के अंदर और बाहर दोनों अलग-अलग नामों के साथ चर का उपयोग करने की कोशिश कर रहा है। लेकिन आपको स्थानीय और वैश्विक स्कोप के बारे में जानना होगा।

परिणाम।

किसी फ़ंक्शन के बाहर बनाया गया एक वैरिएबल ग्लोबल है।

फ़ंक्शन से, आप वैश्विक चर तक पहुंच सकते हैं और इसके मूल्य को बदल सकते हैं।

सूचनाओं के भंडारण के लिए चर "कंटेनर" के रूप में कार्य करते हैं।

क्या आपको स्कूल बीजगणित याद है?

क्या आपको स्कूल की बीजगणित याद है? x \u003d 5, y \u003d 6, z \u003d x + y

क्या आपको याद है कि एक अक्षर (उदाहरण के लिए x) का उपयोग मान (उदाहरण 5) को संग्रहीत करने के लिए किया जा सकता है, और यह कि आप उस z की गणना करने के लिए उपरोक्त जानकारी का उपयोग 11 कर सकते हैं?

ये पत्र कहलाते हैं चर, और चर का उपयोग मूल्यों (x \u003d 5) या भाव (z \u003d x + y) को संग्रहीत करने के लिए किया जा सकता है।

जावास्क्रिप्ट चर

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

एक चर का एक छोटा नाम हो सकता है, जैसे कि x, या अधिक वर्णनात्मक नाम, जैसे कि कारनाम।

जावास्क्रिप्ट चर नामों के नियम:

• परिवर्तनीय नाम केस संवेदी हैं (y और Y दो भिन्न चर हैं)
• चर नामों को एक अक्षर या अंडरस्कोर से शुरू करना चाहिए

टिप्पणी: चूंकि जावास्क्रिप्ट केस संवेदी है, इसलिए वैरिएबल नाम भी केस सेंसिटिव हैं।

उदाहरण

स्क्रिप्ट निष्पादन के दौरान एक चर का मान बदल सकता है। आप इसके मूल्य को प्रदर्शित करने या बदलने के लिए इसके नाम से एक चर का उल्लेख कर सकते हैं।

घोषणा (बनाना) जावास्क्रिप्ट चर

जावास्क्रिप्ट में चर बनाने को आमतौर पर "घोषित" चर कहा जाता है।

आप कीवर्ड का उपयोग करके जावास्क्रिप्ट चर घोषित कर रहे हैं वर:

उपरोक्त कथनों को निष्पादित करने के बाद, चर एक्स मान होगा 5 तथा carname मान होगा मर्सिडीज.

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

टिप्पणी: यदि आप एक चर को फिर से घोषित करते हैं, तो यह अपना मूल्य नहीं खोएगा।

जावास्क्रिप्ट स्थानीय चर

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

आप विभिन्न कार्यों में एक ही नाम के साथ स्थानीय चर घोषित कर सकते हैं, क्योंकि स्थानीय चर उस फ़ंक्शन में पहचाने जाते हैं जिसमें वे घोषित किए जाते हैं।

फ़ंक्शन से बाहर निकलने पर स्थानीय चर नष्ट हो जाते हैं।

आप जावास्क्रिप्ट पाठ के बाद के कार्यों के बारे में अधिक जानेंगे।

जावास्क्रिप्ट वैश्विक चर

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

जब आप पृष्ठ बंद करते हैं तो वैश्विक चर नष्ट हो जाते हैं।

यदि आप "चर" का उपयोग किए बिना एक चर घोषित करते हैं, तो चर हमेशा बन जाता है ग्लोबल.

अघोषित जावास्क्रिप्ट चर के मान को निर्दिष्ट करना

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

ये सुझाव:

आप अगले जावास्क्रिप्ट ट्यूटोरियल में ऑपरेटरों के बारे में अधिक जानेंगे।

जावास्क्रिप्ट में वैश्विक चर

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

हैलो \u003d "हैलो"; // एक वैश्विक चर सेट करें और इसे जांचें
document.writeln ("-\u003e 1" + हैलो + "हर एक
"); // -\u003e 1 हर एक को नमस्कार

यदि सत्य हैं)
// यदि (असत्य)
{
var हैलो \u003d "हैलो डॉली और"; // यह भी वैश्विक है
दुनिया \u003d "दुनिया"; // वैश्विक
var cont \u003d ", हम जारी रखते हैं" // वैश्विक
document.writeln ("-\u003e 1.2" + हैलो + दुनिया + कंट + "
");
//1.
}
document.writeln ("-\u003e 2" + हैलो + दुनिया + प्रतियोगिता + "
");
// -\u003e 2 नमस्ते डॉली और दुनिया, हम जारी रखते हैं

अगर सच है, तो हमें जवाब मिलता है

-\u003e 1 हर एक को नमस्कार
-\u003e 1.2 नमस्ते डॉली और दुनिया, हम जारी रखते हैं
-\u003e 2 हैलो डॉली और दुनिया, हम जारी रखते हैं

अत्याचार निरस्त करता है

इस प्रकार, यह पता चला है कि var का उपयोग किसी भी तरह से वैश्विक दायरे को प्रभावित नहीं करता है। प्रक्रियाओं के बाहर एक स्क्रिप्ट में उल्लिखित एक चर को वैश्विक माना जाता है, भले ही वह ब्रैकेट में संलग्न हो () यदि ब्लॉक और अन्य स्कोप के लिए है तो भी छोरों के भीतर वैश्विक ही रहता है

निष्कर्ष, संक्षेप में

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

स्थानीय चर निष्पादन योग्य ब्लॉक (फ़ंक्शन) के भीतर सेट किए गए चर हैं और अन्य कार्यों को प्रभावित नहीं करते हैं। और बाहरी वातावरण, अर्थात् वैश्विक कार्यक्षेत्र।

लड़का \u003d "Jhone";
किया \u003d "केनी को मारता है"; // इसलिए हमारे पास 2 वैश्विक चर हैं
फ़ंक्शन doit ()
{
// मुद्रण पहले ही पास हो गया है - 1, और हम डेटा बदलते हैं, डेटा बदलते हैं
var लड़का \u003d "गैरी"; // एक लोकेल बनाएं
किया \u003d "एनी की मदद करता है"; // वैश्विक परिवर्तन
;
document.writeln ("- 2" + लड़का + "" + किया + "
");
// - 2 गैरी मदद करता है एनी
;
// अब, फ़ंक्शन के अंदर, स्थानीय और वैश्विक चर सेट करें
var अच्छा \u003d "वह एक अच्छा लड़का था
"; // स्थानीय!
bad \u003d "वह एक बुरी लड़कियों को पसंद करता है
", // वैश्विक
}
;
document.writeln ("- 1" + लड़का + "" + किया + "
");
// - 1 जोनी केनी को मारता है
कर दो ();
// - 2 गैरी मदद करता है एनी
document.writeln ("- 3" + लड़का + "" + किया + "
");
// - 3 Jhone एनी की मदद करता है
;
यदि सत्य हैं)
// अगर (झूठा)
{
document.writeln ("- 4" + अच्छा);
// इस ब्लॉक के निष्पादन में त्रुटि होगी।
// हम वर्तमान में स्थानीय दायरे से बाहर हैं
// doit () फ़ंक्शन, इसलिए हमारे लिए, var के माध्यम से दिया गया है
// चर अच्छा सिर्फ मौजूद नहीं है
}
document.writeln ("- 5" + खराब);
// - 5 वह एक बुरी लड़कियों को पसंद करता है

परिणाम:

1 जेनी केनी को मारता है
- 2 गैरी एनी की मदद करता है
- 3 Jhone एनी की मदद करता है
- 5 वह एक बुरी लड़कियों को पसंद करता है

जावास्क्रिप्ट में स्थानीय चर

* var स्थानीय चर घोषित करके एक फंक्शन के अंदर काम करता है। यह उनका मुख्य कार्य है।

* Javascrip, सिर्फ़ उसी (?) में सी से बहुत अलग है। एक फंक्शन के अंदर स्थानीय वेरिएबल्स संभव हैं।
* वैश्विक दायरे में इसका उपयोग करना या नहीं करना केवल आपके व्यक्तिगत अनुभव पर निर्भर करता है। लेकिन मेरे लिए आलसी न होना बेहतर है। मोती में इसे उपयोग सख्त कहा जाता है

\u003e\u003e\u003e वैरिएबल ग्लोबल स्कोप में इस्तेमाल होने वाले वेरिएबल्स के लिए महत्वपूर्ण नहीं है

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

वार glb_1 \u003d 1;
अगर (झूठा) (var glb_2 \u003d 2; glb_3 \u003d 3;)

चेतावनी (glb_1) // तत्काल और मान 1 प्राप्त हुआ
सतर्क (glb_2) // बाहर निकाल दिया और मान 'अपरिभाषित'
चेतावनी (glb_3) // कॉलिंग करते समय कोई चर (कोई संस्करण नहीं), एक त्रुटि

अंतिम अपडेट: 05.04.2018

सभी जावास्क्रिप्ट चर में एक विशिष्ट गुंजाइश है जिसके भीतर वे कार्य कर सकते हैं।

सार्वत्रिक चर

कार्यों के बाहर घोषित किए गए सभी चर वैश्विक हैं:

यहाँ चर x और d वैश्विक हैं। वे कार्यक्रम में कहीं से भी सुलभ हैं।

लेकिन चर z वैश्विक नहीं है, क्योंकि यह फ़ंक्शन के अंदर परिभाषित किया गया है।

स्थानीय चर

एक फ़ंक्शन के अंदर परिभाषित एक चर स्थानीय है:

फंक्शन डिस्प्लेसक्वेयर () (var z \u003d 10; कंसोल.लॉग (z); लेट बी \u003d 8; कंसोल.लॉग (बी);)

चर z और b स्थानीय हैं, वे केवल फ़ंक्शन के भीतर ही मौजूद हैं। वे एक समारोह के बाहर इस्तेमाल नहीं किया जा सकता है:

फंक्शन डिस्प्लेसक्वेयर () (var z \u003d 10; कंसोल.लॉग (जेड); कंसोल) (जेड); // त्रुटि क्योंकि z अपरिभाषित है

जब फ़ंक्शन अपना काम पूरा करता है, तो फ़ंक्शन में परिभाषित सभी चर नष्ट हो जाते हैं।

छिपी हुई चर

क्या होगा अगर हमारे पास दो चर हैं, एक वैश्विक और दूसरा स्थानीय, जिसका एक ही नाम है:

वर z \u003d 89; function displaySquare () (var z \u003d 10; कंसोल .log (z); // 10) displaySquare (); // दस

इस स्थिति में, फ़ंक्शन z चर का उपयोग करेगा जो सीधे फ़ंक्शन में परिभाषित किया गया है। यही है, स्थानीय चर वैश्विक एक को छिपाएगा।

var या लेट

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

चलो z \u003d 10; function displayZ () (z \u003d 20; (let z \u003d 30; कंसोल .log ("ब्लॉक:", z);) कंसोल.log ("फ़ंक्शन:", z);) डिस्प्लेज़ (); कंसोल.लॉग ("ग्लोबल:", जेड);

यहां, डिस्प्लेज़ फ़ंक्शन के अंदर, कोड का एक ब्लॉक परिभाषित किया गया है जिसमें चर z परिभाषित किया गया है। यह ग्लोबल वेरिएबल और फंक्शन-लेवल z वेरिएबल को छुपाता है। एक वास्तविक कार्यक्रम में, एक ब्लॉक नेस्टेड फ़ंक्शन का प्रतिनिधित्व कर सकता है, एक लूप के लिए, या यदि कथन। लेकिन किसी भी मामले में, ऐसा ब्लॉक एक नए दायरे को परिभाषित करता है, जिसके बाहर चर मौजूद नहीं है।

और इस मामले में, हमें निम्नलिखित कंसोल आउटपुट मिलते हैं:

ब्लॉक: 30 समारोह: 20 ग्लोबल: 10

वर्जन स्टेटमेंट के साथ, हम एक फंक्शन में और इस फंक्शन में कोड के ब्लॉक में एक ही नाम के साथ एक वेरिएबल को परिभाषित नहीं कर सकते हैं:

फंक्शन डिस्प्लेस्क्वेयर () (var z \u003d 20; (var z \u003d 30; // एरर! वैरिएबल z पहले से ही कंसोल .log ("ब्लॉक:", z);) कंसोल.log ("फंक्शन:", z);)

अर्थात्, var का उपयोग करके, हम एक चर को उसी नाम से परिभाषित कर सकते हैं, जो फ़ंक्शन स्तर पर या कोड ब्लॉक स्तर पर होता है।

स्थिरांक

लेट स्टेटमेंट के बारे में सब कुछ कॉन्स्ट स्टेटमेंट पर लागू होता है, जो आपको कॉन्स्टैंट को परिभाषित करने की अनुमति देता है। कोड ब्लॉक स्थिरांक के दायरे को परिभाषित करते हैं, और नेस्टेड कोड ब्लॉक में परिभाषित स्थिरांक एक ही नाम के बाहरी स्थिरांक को छिपाते हैं:

कॉन्स्ट जेड \u003d 10; function displayZ () (const z \u003d 20; (const z \u003d 30; कंसोल .log ("ब्लॉक:", z); // 30) कंसोल.log ("फ़ंक्शन:", z); // 20) displayZ () ); कंसोल.लॉग ("ग्लोबल:", जेड); // दस

अघोषित चर

यदि हम किसी फ़ंक्शन में किसी वैरिएबल को परिभाषित करते समय इस कीवर्ड का उपयोग नहीं करते हैं, तो ऐसा वैरिएबल ग्लोबल होगा। उदाहरण के लिए:

समारोह बार () (फू \u003d "25";) बार (); कंसोल.लॉग (फू); // 25

हालाँकि बार फ़ंक्शन के बाहर कहीं भी फू को परिभाषित नहीं किया गया है, फिर भी यह बाहरी संदर्भ में फ़ंक्शन के बाहर उपलब्ध है।

यह भिन्न होगा यदि हमने न केवल चर को मान दिया है, बल्कि इसे परिभाषित भी किया है:

फंक्शन बार () (var foo \u003d "25";) बार (); कंसोल.लॉग (फू); // गलती

सख्त मोड

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

"सख्त का उपयोग करें"; समारोह बार () (फू \u003d "25";) बार (); कंसोल.लॉग (फू);

इस मामले में, हम एक सिंटेक्सर्योर प्राप्त करेंगे: अप्रत्याशित पहचानकर्ता त्रुटि, जो इंगित करता है कि चर फू को परिभाषित नहीं किया गया है।

सख्त मोड सेट करने के दो तरीके हैं:

जावास्क्रिप्ट कोड की शुरुआत में अभिव्यक्ति "सख्त का उपयोग करें" जोड़ें, फिर पूरे कोड पर सख्त मोड लागू किया जाएगा

फ़ंक्शन बॉडी की शुरुआत में अभिव्यक्ति "सख्त का उपयोग करें" जोड़ें, फिर इस फ़ंक्शन के लिए केवल सख्त मोड लागू किया जाएगा

यह चार-भाग ट्यूटोरियल अच्छा जावास्क्रिप्ट कोड लिखने का तरीका बताता है, जिसे बनाए रखना और विकसित करना आसान है, भले ही आपको लंबे समय के बाद किसी परियोजना में वापस आना पड़े।

इस उम्मीद के साथ कोड लिखें कि इसे बनाए रखना होगा

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

• समस्या का अध्ययन करने और समझने का समय।
• कोड को समझने का समय जो समस्या का स्रोत है।

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

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

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

नतीजतन, कोड को लिखने में कई-कई घंटे लगेंगे, और इसे पढ़ने के लिए कई मानव-दिन। इसलिए, आसानी से बनाए रखने योग्य कोड बनाना आपके आवेदन की सफलता के लिए महत्वपूर्ण है।

कोड बनाए रखने में आसान निम्नलिखित विशेषताएं हैं:

• इसे पढ़ना आसान है।
• यह अच्छी तरह से संरचित है और भागों एक साथ फिट होते हैं।
• यह अनुमानित है।
• ऐसा लग रहा है कि यह एक व्यक्ति द्वारा लिखा गया था।
• प्रलेखित।

वैश्विक चरों के उपयोग को कम करना

जावास्क्रिप्ट संदर्भ में हेरफेर करने के लिए फ़ंक्शंस का उपयोग करता है। कार्यों के अंदर घोषित चर उनके लिए स्थानीय हैं और कार्यों के बाहर उपलब्ध नहीं हैं। वैश्विक चर कार्यों के बाहर घोषित किए जाते हैं या बिना घोषणा के उपयोग किए जाते हैं।

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

वार मायग्लोइड \u003d "हैलो"; कंसोल.लॉग (मायग्लोडी); // "हैलो" कंसोल.लॉग (window.myglobal); // "हैलो" कंसोल.लॉग (खिड़की ["मायग्लोबल"]); // "हैलो" कंसोल.लॉग (this.myglobal); // "हैलो"

वैश्विक चर के साथ समस्याएं

वैश्विक चर के साथ समस्या यह है कि वे आपके एप्लिकेशन या पृष्ठ के जावास्क्रिप्ट कोड में उपलब्ध होंगे। वे वैश्विक नामस्थान में हैं, और हमेशा टकराव के नामकरण के लिए एक मौका होता है जब अनुप्रयोग के दो अलग-अलग हिस्से वैश्विक चर को एक ही नाम से परिभाषित करते हैं लेकिन विभिन्न उद्देश्यों के लिए।

इसके अलावा, आमतौर पर, एक वेब पेज में अन्य डेवलपर्स द्वारा लिखित कोड शामिल होता है। उदाहरण के लिए:

• अन्य जावास्क्रिप्ट पुस्तकालय।
• विज्ञापन भागीदार स्क्रिप्ट।
• उपयोगकर्ता ट्रैकिंग और विश्लेषिकी कोड।
• विभिन्न विगेट्स, बटन और प्लगइन्स।

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

इसलिए, एक ही पृष्ठ पर अलग-अलग कोड को सफलतापूर्वक संयोजित करने के लिए, संभव है कि कुछ वैश्विक चर का उपयोग करें। इस प्रश्न में, चर की घोषणा करते समय var निर्देश का उपयोग एक आवश्यक भूमिका निभाता है।

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

फ़ंक्शन राशि (x, y) (// खराब: निहित वैश्विक परिणाम \u003d x + y; वापसी परिणाम;)

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

न्यूनतम निर्देश का नियम है कि चर निर्देश का उपयोग करके चर को परिभाषित किया जाए। निम्नलिखित राशि () फ़ंक्शन का एक उन्नत संस्करण है:

कार्य राशि (x, y) (var result \u003d x + y; return result;)

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

// बुरा, फ़ंक्शन फू का उपयोग न करें () (var a \u003d b \u003d 0; // ...)

यदि आप हैरान हैं कि क्या हो रहा है, तो यह सही-से-बाएँ गणना है। अभिव्यक्ति b \u003d 0 को पहले निष्पादित किया जाता है, और इसलिए चर b घोषित नहीं किया जाएगा। अभिव्यक्ति का रिटर्न मान 0 होगा, और इसे नए स्थानीय चर a को सौंपा गया है, जिसे var निर्देश द्वारा घोषित किया गया है। चर की यह परिभाषा निम्नलिखित संकेतन के बराबर है:

वार ए \u003d (बी \u003d 0);

यदि आपने पहले ही चर घोषित कर दिया है, तो जंजीर दृश्य ठीक काम करेगा और अवांछित ग्लोबल्स नहीं बनाएगा:

समारोह foo () (var a, b, a \u003d b \u003d 0; // दोनों चर स्थानीय हैं)

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

भुला दिए गए var घोषणा का साइड इफेक्ट

स्पष्ट रूप से परिभाषित और निहित ग्लोबल्स के बीच मामूली अंतर है। इसमें डिलीट ऑपरेटर का उपयोग करके एक चर को हटाने की क्षमता है:

• वैरिएशन के साथ घोषित एक वैश्विक वैरिएबल (प्रोग्राम में कार्यों के बाहर निर्मित) को हटाया नहीं जा सकता है।
• एक घोषणा के बिना बनाया गया एक अंतर्निहित वैश्विक चर (इसकी परवाह किए बिना कि यह कहां बनाया गया था) को हटाया जा सकता है।

तकनीकी रूप से, एक निहित वैश्विक चर वैश्विक वस्तु की एक संपत्ति है, एक चर नहीं। हटाए गए ऑपरेटर का उपयोग करके गुण हटाए जा सकते हैं, लेकिन चर नहीं कर सकते हैं:

// तीन वैश्विक चर को परिभाषित करें global_var \u003d 1; Global_novar \u003d 2; // बुरा (फ़ंक्शन () (Global_fromfunc \u003d 3; // bad) ()); // डिलीट करने का प्रयास कर रहा है global_var; // false delete Global_novar; // true delete global_fromfunc; // true // विलोपन टाइपो के लिए जाँच करें global_var; // "संख्या" टाइपऑफ Global_novar; // "अपरिभाषित" टाइपऑफ Global_fromfunc; // "अपरिभाषित"

वैश्विक वस्तु तक पहुंच

ब्राउज़रों में, वैश्विक ऑब्जेक्ट विंडो प्रॉपर्टी के माध्यम से कोड में कहीं भी उपलब्ध है (जब तक कि आप कुछ विशेष या अप्रत्याशित नहीं करते हैं, जैसे कि स्थानीय चर नाम की विंडो घोषित करना)। लेकिन अन्य वातावरणों में, यह सुविधाजनक संपत्ति दूसरे तरीके से उपलब्ध हो सकती है (या प्रोग्रामर के लिए भी उपलब्ध नहीं है)। यदि आपको विंडो पहचानकर्ता का उपयोग किए बिना वैश्विक ऑब्जेक्ट तक पहुंच की आवश्यकता है, तो आप नेस्टेड फ़ंक्शन नाम सूची के किसी भी स्तर पर निम्न विधि का उपयोग कर सकते हैं:

वार ग्लोबल \u003d (फ़ंक्शन () (इसे वापस करें;) ());

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

एकल संस्करण घोषणा टेम्प्लेट

अपने फ़ंक्शन के शीर्ष पर एक एकल संस्करण घोषणा का उपयोग करना एक बहुत ही उपयोगी अभ्यास है। इस विधि के निम्नलिखित फायदे हैं:

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

एक एकल संस्करण घोषणा के साथ एक टेम्पलेट इस तरह दिखता है:

फंक्शन फंक () (var a \u003d 1, b \u003d 2, sum \u003d a + b, myobject \u003d (), i, j; // फंक्शन कोड ...)

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

आप चर की घोषणा करते समय एक ऑपरेशन भी कर सकते हैं, जैसे पिछले उदाहरण कोड से योग \u003d ए + बी। DOM मैनिपुलेशन एक और कार्यशील उदाहरण है। जब आप घोषणा करते हैं तो आप DOM के तत्वों को स्थानीय चर के संदर्भ में निर्दिष्ट कर सकते हैं:

फंक्शन अपडेटईमेंट () (var el \u003d document.getElementById ("result"), style \u003d.style; // el और स्टाइल के साथ ऑपरेशन करें ...)

भारोत्तोलन: बिखरे हुए var घोषणाओं के साथ समस्या

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

// बुरा myname \u003d "वैश्विक"; // ग्लोबल वेरिएबल फंक्शन फंक () (अलर्ट (myname); // "अपरिभाषित" var myname \u003d "local"; एलर्ट (myname); // "लोकल") func ();

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

पिछला उदाहरण ऐसा कार्य करेगा जैसे इसे लागू किया गया था:

Myname \u003d "ग्लोबल"; // ग्लोबल वेरिएबल फंक्शन फंक () (var myname; // उसी तरह -\u003e var myname \u003d undefined; एलर्ट (myname); // "undefined" myname \u003d "local"; अलर्ट (myname); // " स्थानीय ") दुर्गंध ();

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