जावास्क्रिप्ट को सख्त मोड की आवश्यकता क्यों है?

सख्त मोड आधुनिक जावास्क्रिप्ट का एक महत्वपूर्ण हिस्सा है। यह यह मोड है जो डेवलपर्स को मानक सिंटैक्स की तुलना में अधिक सीमित उपयोग करने की अनुमति देता है।

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



सख्त मोड जावास्क्रिप्ट के शब्दार्थ में कुछ बदलाव पेश करता है। यह उपयुक्त अपवादों को फेंककर सिस्टम को गलत नजर में बदलने से रोकता है। यह प्रोग्राम निष्पादन को रोकने का कारण बनता है।

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

सख्त मोड का उपयोग करने की विशेषताएं

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

यदि प्रोजेक्ट में कुछ स्क्रिप्ट हैं जो सख्त मोड का उपयोग नहीं करते हैं, और अन्य जो इस मोड का उपयोग करते हैं, तो ऐसा हो सकता है कि ये स्क्रिप्ट विलय हो।

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

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

उदाहरण के लिए:

 const strictFunction = ()=>{  'use strict';  const nestedFunction = ()=>{    //        } } 

ES2015 मानक में दिखाई देने वाले जावास्क्रिप्ट मॉड्यूल में, सख्त मोड डिफ़ॉल्ट रूप से सक्षम है। इसलिए, उनके साथ काम करते समय, आपको इसे स्पष्ट रूप से शामिल करने की आवश्यकता नहीं है।

सख्त मोड द्वारा जेएस कोड में परिवर्तन लाया गया

सख्त मोड कोड के सिंटैक्स दोनों को प्रभावित करता है और कोड जिस तरह से प्रोग्राम के निष्पादन के दौरान व्यवहार करता है। कोड में त्रुटियां अपवाद में बदल जाती हैं। तथ्य यह है कि शांत मोड में चुपचाप सख्त मोड में क्रैश होता है, एक त्रुटि संदेश का कारण बनता है। यह उसी तरह है जैसे सिस्टम ने लैक्स मोड में सिंटैक्स त्रुटियों का जवाब दिया। सख्त मोड में, चर के साथ काम करना सरल होता है, eval फ़ंक्शन का उपयोग और arguments ऑब्जेक्ट को कसकर विनियमित किया जाता है, और निर्माण के साथ काम किया जाता है जिसे भाषा के भविष्य के संस्करणों में कार्यान्वित किया जा सकता है।

Silent मौन त्रुटियों को अपवाद में बदलें

साइलेंट एरर्स को कड़े मोड में अपवादों में बदला जाता है। लैक्स मोड में, सिस्टम ऐसी त्रुटियों के लिए स्पष्ट रूप से प्रतिक्रिया नहीं देता है। सख्त मोड में, ऐसी त्रुटियों की उपस्थिति कोड की निष्क्रियता की ओर ले जाती है।

तो, इसके लिए धन्यवाद, गलती से वैश्विक परिवर्तनशील घोषित करने की गलती करना मुश्किल है, क्योंकि चर, स्थिरांक या स्थिरांक को बिना वेरिएबल, const या निर्देश के उपयोग के बिना घोषित नहीं किया जा सकता है। परिणामस्वरूप, इन निर्देशों के बिना वैरिएबल बनाने से प्रोग्राम इनऑपरिबिलिटी हो जाएगी। उदाहरण के लिए, निम्नलिखित कोड को निष्पादित करने का प्रयास एक ReferenceError अपवाद को फेंक देगा:

 'use strict'; badVariable = 1; 

इस तरह के कोड को सख्त मोड में नहीं चलाया जा सकता है, क्योंकि यदि सख्त मोड को बंद कर दिया गया है, तो यह वैश्विक चर को badVariable । सख्त मोड प्रोग्रामर को अनजाने में वैश्विक चर बनाने से बचाता है।

किसी भी कोड को निष्पादित करने का प्रयास, जो सामान्य मोड में, बस काम नहीं करता है, अब एक अपवाद फेंकता है। त्रुटियों को किसी भी गलत सिंटैक्टिक निर्माण के रूप में माना जाता है जिसे केवल लैक्स मोड में अनदेखा किया गया था।

इसलिए, उदाहरण के लिए, सख्त मोड में, आप केवल-पढ़ने वाली संस्थाओं जैसे कि arguments , NaN या eval पर मान असाइनमेंट ऑपरेशन नहीं कर सकते।

सख्त मोड में, एक अपवाद, उदाहरण के लिए, निम्नलिखित मामलों में फेंक दिया जाएगा:

• मूल्य को केवल-पढ़ने के लिए एक संपत्ति निर्दिष्ट करने का प्रयास, जैसे कि कुछ प्रकार की फिर से लिखने योग्य वैश्विक संपत्ति;
• एक संपत्ति के लिए एक मूल्य लिखने का प्रयास जिसमें केवल एक गटर होता है;
• एक गैर-एक्स्टेंसिबल ऑब्जेक्ट की संपत्ति के लिए कुछ लिखने का प्रयास।

यहाँ सिंटैक्स निर्माण के उदाहरण हैं जो सख्त मोड अपवादों का नेतृत्व करते हैं:

 'use strict'; let undefined = 5; let Infinity = 5; let obj = {}; Object.defineProperty(obj, 'foo', { value: 1, writable: false }); obj.foo = 1 let obj2 = { get foo() { return 17; } }; obj2.foo = 2 let fixedObj = {}; Object.preventExtensions(fixedObj); fixed.bar= 1; 

इस तरह के कोड अंशों को सख्त मोड में निष्पादित करने का प्रयास एक TypeError अपवाद को फेंक देगा। उदाहरण के लिए, undefined और Infinity वैश्विक संस्थाएं हैं जिनके मूल्यों को अधिलेखित नहीं किया जा सकता है, और ओब्जेक्ट ऑब्जेक्ट की foo संपत्ति पुनर्लेखन का समर्थन नहीं करती है। obj2 की foo प्रॉपर्टी में केवल एक गेटर है। fixedObj ऑब्जेक्ट fixedObj Object.preventExtensions विधि का उपयोग करके गैर-एक्स्टेंसिबल बनाया fixedObj है।

एक TypeError को हटाने का प्रयास भी TypeError में परिणाम देगा:

 'use strict'; delete Array.prototype 

सख्त मोड एक वस्तु के समान नाम के साथ गुण निर्दिष्ट करने पर रोक लगाता है। परिणामस्वरूप, निम्नलिखित कोड को निष्पादित करने के प्रयास में एक सिंटैक्स त्रुटि होगी:

 'use strict'; let o = { a: 1, a: 2 }; 

सख्त मोड को अद्वितीय होने के लिए फ़ंक्शन पैरामीटर नामों की आवश्यकता होती है। गैर-सख्त मोड में, यदि, उदाहरण के लिए, किसी फ़ंक्शन के दो मापदंडों का एक ही नाम one , तो, जब तर्क फ़ंक्शन को पास करते हैं, तो पैरामीटर मान वह होगा जो अंतिम घोषित किए गए तर्क में गिर गया।

सख्त मोड में, समान नाम वाले फ़ंक्शन के पैरामीटर निषिद्ध हैं। परिणामस्वरूप, निम्नलिखित कोड को निष्पादित करने के प्रयास में एक सिंटैक्स त्रुटि होगी:

 'use strict'; const multiply = (x, x, y) => x*x*y; 

सख्त मोड में, आप संख्याओं के ऑक्टल नोटेशन का उपयोग नहीं कर सकते हैं, संख्या को शून्य से पहले। यह विनिर्देश में नहीं है, लेकिन यह सुविधा ब्राउज़रों द्वारा समर्थित है।

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

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

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

मान लीजिए कि इस तरह एक कोड है:

 let x = 1; with (obj) {  x; } 

दुभाषिया यह पता लगाने में सक्षम नहीं होगा कि ब्लॉक के with स्थित चर x बाहरी चर x को संदर्भित करता है, या obj.x गुण obj ऑब्जेक्ट को।

नतीजतन, यह स्पष्ट रूप से स्पष्ट नहीं है कि स्मृति में x मूल्य कहां स्थित होगा। ऐसी अस्पष्टताओं से छुटकारा पाने के लिए, सख्त मोड में कथन के with उपयोग निषिद्ध है। आइए देखें कि यदि आप निम्न कोड को सख्त मोड में निष्पादित करने का प्रयास करते हैं तो क्या होता है:

 'use strict'; let x = 1; with (obj) {  x; } 

इस प्रयास का परिणाम एक सिंटैक्स त्रुटि होगी।

यहां तक ​​कि सख्त मोड में, eval विधि में पारित कोड में चर घोषित करने के लिए मना किया गया है।

उदाहरण के लिए, सामान्य मोड में, प्रपत्र eval('let x') की एक कमांड के परिणामस्वरूप चर x की घोषणा होगी। यह प्रोग्रामर्स को स्ट्रिंग्स में वैरिएबल घोषणाओं को छिपाने की अनुमति देता है, जिससे eval बाहर समान वेरिएबल्स की परिभाषाओं को ओवरराइट किया जा सकता है।

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

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

 'use strict'; let x; delete x; 

गलत सिंटैक्स का निर्माण synt

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

यहां उदाहरणों और arguments के दुरुपयोग के उदाहरण हैं:

 'use strict'; eval = 1; arguments++; arguments--; ++eval; eval--; let obj = { set p(arguments) { } }; let eval; try { } catch (arguments) { } try { } catch (eval) { } function x(eval) { } function arguments() { } let y = function eval() { }; let eval = ()=>{ }; let f = new Function('arguments', "'use strict'; return 1;"); 

सख्त मोड में, आप arguments ऑब्जेक्ट के लिए उपनाम नहीं बना सकते हैं और इन उपनामों के माध्यम से नए arguments मान सेट कर सकते हैं।

सामान्य मोड में, यदि फ़ंक्शन का पहला पैरामीटर a , तो फ़ंक्शन कोड में मान सेट करने से भी arguments[0] में मान में परिवर्तन होता है arguments[0] । सख्त मोड में, arguments में हमेशा उन arguments की सूची होगी, जिनके साथ फ़ंक्शन को बुलाया गया था।

मान लें कि आपके पास निम्नलिखित कोड हैं:

 const fn = function(a) {  'use strict';  a = 2;  return [a, arguments[0]]; } console.log(fn(1)) 

कंसोल को [2,1] मिलेगा। ऐसा इसलिए है क्योंकि 2 के मान को लिखते नहीं है 2 के मान को arguments[0] से नहीं लिखते हैं arguments[0] ।

PtOptimize प्रदर्शन

सख्त मोड में, arguments.callee संपत्ति का समर्थन नहीं किया जाता है। सामान्य मोड में, यह उस फ़ंक्शन के मूल फ़ंक्शन का नाम देता है जिसकी arguments की callee संपत्ति जिस ऑब्जेक्ट की हम जांच कर रहे हैं।

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

सख्त मोड में, this को हमेशा एक ऑब्जेक्ट नहीं होना चाहिए। सामान्य परिस्थितियों में, यदि this फ़ंक्शन बाध्य है, तो call का उपयोग करना, apply या bind , ऐसी चीज़ के लिए जो एक वस्तु नहीं है, एक आदिम प्रकार के मान जैसे undefined , null , number या boolean , ऐसा मान एक वस्तु होना चाहिए।

यदि this वस्तु का संदर्भ किसी ऐसी वस्तु में बदल जाता है जो वस्तु नहीं है, तो वैश्विक वस्तु अपना स्थान ले लेती है। उदाहरण के लिए, window । इसका मतलब यह है कि यदि आप किसी फ़ंक्शन को इसके मान से सेट this , जो कि ऑब्जेक्ट नहीं है, तो इस मान के बजाय, वैश्विक ऑब्जेक्ट का एक संदर्भ इसमें आएगा।

एक उदाहरण पर विचार करें:

 'use strict'; function fn() {  return this; } console.log(fn() === undefined); console.log(fn.call(2) === 2); console.log(fn.apply(null) === null); console.log(fn.call(undefined) === undefined); console.log(fn.bind(true)() === true); 

सभी console.log कमांड true से आउटपुट करेंगे, क्योंकि सख्त मोड में फ़ंक्शन का मान स्वचालित रूप से वैश्विक ऑब्जेक्ट के संदर्भ में प्रतिस्थापित नहीं होता है यदि this उस मान पर सेट होता है जो ऑब्जेक्ट नहीं है।

▍ सुरक्षा-संबंधी परिवर्तन

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

arguments ऑब्जेक्ट फ़ंक्शन को उस तर्क को संग्रहीत करता है जब उसे बुलाया गया था। उदाहरण के लिए, यदि हमारे पास एक फ़ंक्शन fn , तो इसका मतलब है कि fn.caller माध्यम से आप फ़ंक्शन को कॉल कर सकते हैं, जो फ़ंक्शन को कॉल करता है, और fn.arguments का उपयोग fn.arguments आप fn को पास किए गए तर्कों को देख सकते हैं जब इसे कॉल किया गया था।

इन सुविधाओं से संभावित सुरक्षा जोखिम पैदा होता है। नतीजतन, इन गुणों तक पहुंच सख्त मोड में निषिद्ध है।

 function secretFunction() {  'use strict';  secretFunction.caller;  secretFunction.arguments; } function restrictedRunner() {  return secretFunction(); } restrictedRunner(); 

पिछले उदाहरण में, हम सख्त मोड में, secretFunction.caller और secretFunction.arguments तक पहुंच secretFunction.caller नहीं कर सकते हैं। तथ्य यह है कि इन गुणों का उपयोग फ़ंक्शन कॉल के ढेर को प्राप्त करने के लिए किया जा सकता है। यदि आप इस कोड को चलाने का प्रयास करते हैं, तो TypeError अपवाद TypeError जाएगा।

सख्त मोड में, पहचानकर्ता जिनका उपयोग जावास्क्रिप्ट के भविष्य के संस्करणों में किया जा सकता है, का उपयोग चर या वस्तुओं के गुणों के नाम के लिए नहीं किया जा सकता है। उदाहरण के लिए, हम निम्नलिखित पहचानकर्ताओं के बारे में बात कर रहे हैं: implements , interface , let , package , private , protected , public , static और yield ।

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

परिणाम

सख्त मोड एक मानक है जो कई वर्षों से अस्तित्व में है। यह बहुत व्यापक ब्राउज़र समर्थन प्राप्त है। सख्त-मोड कोड वाली समस्याएं केवल पुराने ब्राउज़र में हो सकती हैं, जैसे कि इंटरनेट एक्सप्लोरर।

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

प्रिय पाठकों! क्या आप अपनी परियोजनाओं के लिए JS कोड लिखते समय सख्त मोड का उपयोग करते हैं?