javascript - जावास्क्रिप्ट में "सख्त उपयोग" क्या करता है, और इसके पीछे तर्क क्या है?




syntax jslint (17)

हाल ही में, मैंने क्रॉकफोर्ड के JSLint के माध्यम से अपना कुछ जावास्क्रिप्ट कोड चलाया, और उसने निम्न त्रुटि दी:

लाइन 1 वर्ण 1 में समस्या: गायब "सख्त उपयोग करें" कथन।

कुछ खोज कर, मुझे एहसास हुआ कि कुछ लोग "use strict"; जोड़ते हैं "use strict"; अपने जावास्क्रिप्ट कोड में। एक बार जब मैंने कथन जोड़ा, तो त्रुटि प्रकट हो गई। दुर्भाग्यवश, Google ने इस स्ट्रिंग स्टेटमेंट के पीछे अधिकांश इतिहास प्रकट नहीं किया था। निश्चित रूप से ब्राउज़र के द्वारा जावास्क्रिप्ट की व्याख्या कैसे की जाती है, इसके बारे में कुछ करना होगा, लेकिन मुझे नहीं पता कि प्रभाव क्या होगा।

तो "use strict"; क्या है "use strict"; सब के बारे में, यह क्या मतलब है, और यह अभी भी प्रासंगिक है?

क्या मौजूदा ब्राउज़र में से कोई भी "use strict"; जवाब देता है "use strict"; स्ट्रिंग या भविष्य के उपयोग के लिए है?

https://code.i-harness.com


'use strict'; उपयोग 'use strict'; करना 'use strict'; अचानक आपके कोड को बेहतर नहीं बनाता है।

जावास्क्रिप्ट सख्त मोड ECMAScript 5 में एक विशेषता है। आप इसे अपनी स्क्रिप्ट / फ़ंक्शन के शीर्ष में घोषित करके सख्त मोड सक्षम कर सकते हैं।

'use strict';

जब कोई जावास्क्रिप्ट इंजन इस निर्देश को देखता है, तो यह कोड को विशेष मोड में समझना शुरू कर देगा। इस मोड में, त्रुटियों को फेंक दिया जाता है जब कुछ कोडिंग प्रथाएं संभावित बग्स को समाप्त कर सकती हैं (जो सख्त मोड के पीछे तर्क है)।

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

var a = 365;
var b = 030;

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

सख्त मोड में विशिष्टताओं की एक गैर-संपूर्ण सूची के लिए, यह उत्तर देखें।

मुझे 'use strict'; उपयोग 'use strict'; उपयोग कहां करना चाहिए 'use strict'; ?

  • मेरे नए जावास्क्रिप्ट एप्लिकेशन में: बिलकुल! जब आप अपने कोड के साथ कुछ बेवकूफ कर रहे हों तो सख्त मोड का उपयोग व्हिस्टलब्लॉवर के रूप में किया जा सकता है।

  • मेरे मौजूदा जावास्क्रिप्ट कोड में: शायद नहीं! यदि आपके मौजूदा जावास्क्रिप्ट कोड में ऐसे कथन हैं जो सख्त मोड में निषिद्ध हैं, तो एप्लिकेशन बस टूट जाएगा। यदि आप सख्त मोड चाहते हैं, तो आपको अपने मौजूदा कोड को डीबग और सही करने के लिए तैयार रहना चाहिए। यही कारण है कि 'use strict'; उपयोग 'use strict'; अचानक आपके कोड को बेहतर नहीं बनाता है

मैं सख्त मोड का उपयोग कैसे करूं?

  1. एक 'use strict'; डालें 'use strict'; आपकी लिपि के शीर्ष पर बयान:

    // File: myscript.js
    
    'use strict';
    var a = 2;
    ....
    

    ध्यान दें कि फ़ाइल myscript.js में सबकुछ सख्त मोड में व्याख्या किया जाएगा।

  2. या, 'use strict'; डालें 'use strict'; आपके फ़ंक्शन बॉडी के शीर्ष पर बयान:

    function doSomething() {
        'use strict';
        ...
    }
    

    कार्य के व्याख्यात्मक दायरे में सबकुछ कुछ सख्त मोड में व्याख्या किया जाएगा। शब्दावली का दायरा शब्द यहां महत्वपूर्ण है। एक बेहतर स्पष्टीकरण के लिए यह जवाब देखें।

सख्त मोड में क्या चीजें निषिद्ध हैं?

मुझे सख्त मोड में निषिद्ध कई चीजों का वर्णन करने वाला एक अच्छा लेख मिला (ध्यान दें कि यह एक विशेष सूची नहीं है):

क्षेत्र

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

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

सख्त कोड के लाभों में से एक यह है कि यूयूआई कंप्रेसर जैसे उपकरण इसे संसाधित करते समय बेहतर काम कर सकते हैं।

लागू ग्लोबल वैरिएबल

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

वैश्विक रिसाव

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

शोर असफलता

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

अष्टभुजाकार

संख्याओं का ऑक्टल (या बेस 8) प्रतिनिधित्व बेहद उपयोगी था जब मशीनों पर मशीन-स्तरीय प्रोग्रामिंग करना जिनके शब्द आकार 3 से अधिक थे। आपको सीडीसी 6600 मेनफ्रेम के साथ काम करते समय ऑक्टल की आवश्यकता थी, जिसमें 60 बिट्स का शब्द आकार था। यदि आप ऑक्टल पढ़ सकते हैं, तो आप 20 शब्द के रूप में एक शब्द देख सकते हैं। दो अंकों ने ओप कोड का प्रतिनिधित्व किया, और एक अंक 8 रजिस्टरों में से एक की पहचान की। मशीन कोड से उच्च स्तर की भाषाओं में धीमी संक्रमण के दौरान, यह प्रोग्रामिंग भाषाओं में ऑक्टल रूप प्रदान करने के लिए उपयोगी माना जाता था।

सी में, ऑक्टेटनेस का एक बेहद दुर्भाग्यपूर्ण प्रतिनिधित्व चुना गया था: अग्रणी शून्य। तो सी में, 0100 अर्थ है 64, 100 नहीं, और 08 एक त्रुटि है, न कि 8. नहीं। दुर्भाग्य से, इस अनाचारवाद को जावास्क्रिप्ट समेत लगभग सभी आधुनिक भाषाओं में कॉपी किया गया है, जहां इसका उपयोग केवल त्रुटियों को बनाने के लिए किया जाता है। इसका कोई अन्य उद्देश्य नहीं है। तो सख्त मोड में, ऑक्टल रूपों की अब अनुमति नहीं है।

एट कैटेरा

तर्क छद्म सरणी ईएस 5 में थोड़ा और सरणी बन जाती है। सख्त मोड में, यह अपने callee और caller गुणों को खो देता है। यह आपके arguments को अविश्वसनीय संदर्भ देने के बिना अविश्वसनीय कोड को पास करना संभव बनाता है। साथ ही, arguments की arguments संपत्ति समाप्त हो जाती है।

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

भविष्य के जावास्क्रिप्ट संस्करणों के लिए आरक्षित शब्द

ईसीएमएस्क्रिप्ट 5 आरक्षित शब्दों की एक सूची जोड़ता है। यदि आप उन्हें चर या तर्क के रूप में उपयोग करते हैं, तो सख्त मोड एक त्रुटि फेंक देगा। आरक्षित शब्द हैं:

implements , interface , let , package , private , protected , public , static , और yield

आगे की पढाई


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

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

मुझे लगता है कि यह एक घातक कैज्ड जानवर है, भले ही "use strict" अच्छी चीजें हो सकती है, लेकिन आपको इसे सही करना है। सख्त जाने का सबसे अच्छा समय यह है कि जब आपकी परियोजना ग्रीनफील्ड है और आप खरोंच से शुरू कर रहे हैं। JSHint/JSLint को सभी चेतावनियों और विकल्पों के साथ कॉन्फ़िगर करें, जैसे आपकी टीम पेट कर सकती है, Grunt+Karma+Chai जैसी कठोर बिल्ड / टेस्ट / जोर प्रणाली सिस्टम डू पत्र प्राप्त करें, और केवल तब ही अपने सभी नए मॉड्यूल को "use strict" । बहुत सारी त्रुटियों और चेतावनियों को ठीक करने के लिए तैयार रहें। JSHint/JSLint किसी भी उल्लंघन का उत्पादन करता है तो सुनिश्चित करें कि हर कोई विफल होने के निर्माण को कॉन्फ़िगर करके गुरुत्वाकर्षण को समझता है।

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


बयान "use strict"; ब्राउज़र को सख्त मोड का उपयोग करने के लिए निर्देश देता है, जो जावास्क्रिप्ट का एक कम और सुरक्षित सुविधा सेट है।

सुविधाओं की सूची (गैर-संपूर्ण)

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

  2. मूक असफल असाइनमेंट सख्त मोड में त्रुटि फेंक देगा ( NaN = 5; असाइन करना NaN = 5; )

  3. delete Object.prototype गुणों को हटाने के प्रयास फेंक देंगे ( delete Object.prototype )

  4. ऑब्जेक्ट में सभी संपत्ति नामों को शाब्दिक होने के लिए शाब्दिक ( var x = {x1: "1", x1: "2"} )

  5. फ़ंक्शन पैरामीटर नाम अद्वितीय होना चाहिए ( function sum (x, x) {...} )

  6. फोर्बिड्स ऑक्टल सिंटैक्स ( var x = 023; कुछ देव गलत तरीके से मानते हैं कि पिछले शून्य संख्या को बदलने के लिए कुछ भी नहीं करता है।)

  7. कीवर्ड के with फोर्बिड्स

  8. सख्त मोड में eval नए चर परिचय नहीं है

  9. सादे नामों को हटाने वाले फोर्बिड्स ( delete x; )

  10. किसी भी रूप में नाम eval और arguments बाध्यकारी या असाइनमेंट फोर्बिड्स

  11. सख्त मोड औपचारिक मानकों के साथ arguments ऑब्जेक्ट्स के गुणों को उपनाम नहीं करता है। (यानी function sum (a,b) { return arguments[0] + b;} यह काम करता है क्योंकि arguments[0] एक के लिए बाध्य है।)

  12. arguments.callee समर्थित नहीं है

[रेफरी: सख्त मोड , मोज़िला डेवलपर नेटवर्क ]


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

आप अधिक जानकारी के लिए एमडीएन दस्तावेज का उल्लेख कर सकते हैं।

ईसीएमएस्क्रिप्ट 5 में पेश किया गया एक निर्देश "use strict"

निर्देश बयान के समान हैं, फिर भी अलग हैं।

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

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

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

  • आप सख्त मोड में -स्टेटमेंट का उपयोग नहीं कर सकते हैं।
  • सख्त मोड में सभी चर घोषित किए जाने चाहिए: यदि आप पहचानकर्ता को मान निर्दिष्ट करते हैं जिसे वैरिएबल, फ़ंक्शन, फ़ंक्शन पैरामीटर, कैच-क्लॉज पैरामीटर या ग्लोबल Object की प्रॉपर्टी के रूप में घोषित नहीं किया गया है, तो आपको एक ReferenceError मिलेगी। सामान्य मोड में पहचानकर्ता को वैश्विक चर के रूप में घोषित किया जाता है (वैश्विक Object की संपत्ति के रूप में)
  • सख्त मोड में कीवर्ड में ऐसे कार्यों में undefined मूल्य होता है जिन्हें कार्यों के रूप में बुलाया जाता था (विधियों के रूप में नहीं)। (सामान्य मोड में this हमेशा वैश्विक Object को इंगित करता है)। इस अंतर का प्रयोग यह जांचने के लिए किया जा सकता है कि कार्यान्वयन सख्त मोड का समर्थन करता है या नहीं:
var hasStrictMode = (function() { "use strict"; return this===undefined }());
  • साथ ही जब call() साथ एक फ़ंक्शन लागू किया जाता है या सख्त मोड में apply है, तो this call() के पहले तर्क का सही मूल्य है या apply() आमंत्रण। (सामान्य मोड में null और undefined वैश्विक Object और मानों द्वारा प्रतिस्थापित किया जाता है, जो वस्तुओं नहीं हैं, वस्तुओं में डाले जाते हैं।)

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

  • सख्त मोड में, जब eval() को कोड पास करते हैं, तो आप कॉलर के दायरे में चर या फ़ंक्शन घोषित या परिभाषित नहीं कर सकते (जैसा कि आप इसे सामान्य मोड में कर सकते हैं)। इसके बजाय, eval() के लिए एक नया दायरा बनाया गया है और चर और कार्य उस दायरे में हैं। eval() निष्पादन खत्म होने के बाद उस दायरे को नष्ट कर दिया गया है।
  • सख्त मोड में किसी फ़ंक्शन के तर्क-ऑब्जेक्ट में मानों की एक स्थिर प्रति होती है, जो उस फ़ंक्शन को पास की जाती है। सामान्य मोड में तर्क-वस्तु का कुछ हद तक "जादुई" व्यवहार होता है: सरणी के तत्व और नामित फ़ंक्शन पैरामीटर दोनों एक ही मान का संदर्भ देते हैं।
  • सख्त मोड में आपको एक SyntaxError मिल जाएगी जब delete ऑपरेटर को गैर-योग्य पहचानकर्ता (एक चर, फ़ंक्शन या फ़ंक्शन पैरामीटर) के बाद किया जाता है। सामान्य मोड में delete अभिव्यक्ति कुछ भी नहीं करेगी और इसका मूल्यांकन false
  • सख्त मोड में जब आप एक कॉन्फ़िगर करने योग्य प्रॉपर्टी को हटाने का प्रयास करते हैं तो आपको TypeError मिल जाएगा। (सामान्य मोड में प्रयास बस विफल रहता है और delete अभिव्यक्ति का मूल्यांकन false )।
  • सख्त मोड में इसे एक वाक्य रचनात्मक त्रुटि माना जाता है जब आप ऑब्जेक्ट शाब्दिक के लिए एक ही नाम के साथ कई गुणों को परिभाषित करने का प्रयास करते हैं। (सामान्य मोड में कोई त्रुटि नहीं है।)
  • सख्त मोड में इसे एक वाक्य रचनात्मक त्रुटि माना जाता है जब फ़ंक्शन घोषणा के समान नाम वाले एकाधिक पैरामीटर होते हैं। (सामान्य मोड में कोई त्रुटि नहीं है।)
  • सख्त मोड में ऑक्टल अक्षरों की अनुमति नहीं है (ये शब्द हैं जो 0x शुरू होते हैं। (सामान्य मोड में कुछ कार्यान्वयन ऑक्टल अक्षरों को अनुमति देते हैं।)
  • सख्त मोड में पहचानकर्ता eval और arguments कीवर्ड की तरह व्यवहार किया जाता है। आप उनका मान नहीं बदल सकते हैं, उन्हें मूल्य निर्दिष्ट नहीं कर सकते हैं, और आप उन्हें चर, फ़ंक्शन, फ़ंक्शन पैरामीटर या कैच ब्लॉक के पहचानकर्ताओं के नाम के रूप में उपयोग नहीं कर सकते हैं।
  • सख्त मोड में कॉल स्टैक की जांच करने की संभावनाओं पर अधिक प्रतिबंध हैं। arguments.caller और arguments.callee सख्त मोड में किसी फ़ंक्शन में TypeError कारण बनता है। इसके अलावा, कुछ कॉलर- और कड़ाई से मोड में फ़ंक्शंस के गुण गुण टाइप करते हैं जब आप उन्हें पढ़ने का प्रयास करते हैं।

यदि आप पिछले वर्ष या तो जारी किए गए ब्राउज़र का उपयोग करते हैं तो यह संभवतः जावास्क्रिप्ट सख्त मोड का समर्थन करता है। ईसीएमएस्क्रिप्ट 5 से पहले केवल पुराने ब्राउज़र ही मौजूदा मानक बन गए हैं, इसका समर्थन नहीं करते हैं।

कमांड के चारों ओर उद्धरण सुनिश्चित करते हैं कि कोड अभी भी पुराने ब्राउज़रों में भी काम करेगा (हालांकि सख्त मोड में सिंटैक्स त्रुटि उत्पन्न करने वाली चीजें आम तौर पर उन पुराने ब्राउज़र में कुछ कठोर तरीके से स्क्रिप्ट को खराब करने का कारण बनती हैं)।


यदि लोग use strict उपयोग use strict उपयोग use strict बारे में चिंतित हैं तो यह इस लेख को देखने के लायक हो सकता है:

ब्राउज़र में ECMAScript 5 'सख्त मोड' समर्थन। इसका क्या मतलब है?
NovoGeek.com - कृष्ण का वेबलॉग

यह ब्राउज़र समर्थन के बारे में बात करता है, लेकिन अधिक महत्वपूर्ण बात यह है कि इसे सुरक्षित तरीके से कैसे निपटें:

function isStrictMode(){
    return !this;
} 
/*
   returns false, since 'this' refers to global object and 
   '!this' becomes false
*/

function isStrictMode(){   
    "use strict";
    return !this;
} 
/* 
   returns true, since in strict mode the keyword 'this'
   does not refer to global object, unlike traditional JS. 
   So here, 'this' is 'undefined' and '!this' becomes true.
*/

सख्त मोड सामान्य जावास्क्रिप्ट अर्थशास्त्र में कई बदलाव करता है:

  • त्रुटियों को फेंकने के लिए उन्हें बदलकर कुछ जावास्क्रिप्ट चुप त्रुटियों को समाप्त करता है।

  • उन गलतियों को हल करता है जो जावास्क्रिप्ट इंजन के अनुकूलन करने में मुश्किल बनाते हैं।

  • ईसीएमएस्क्रिप्ट के भविष्य के संस्करणों में परिभाषित होने वाले कुछ वाक्यविन्यास को प्रतिबंधित करता है।

अधिक जानकारी के लिए सख्त मोड- जावास्क्रिप्ट


W3schools से उद्धरण :

"सख्त उपयोग करें" निर्देश

जावास्क्रिप्ट 1.8.5 (ईसीएमएस्क्रिप्ट संस्करण 5) में "सख्त उपयोग" निर्देश नया है।

यह एक बयान नहीं है, लेकिन एक शाब्दिक अभिव्यक्ति, जावास्क्रिप्ट के पिछले संस्करणों द्वारा अनदेखा किया गया है।

"सख्त उपयोग" का उद्देश्य यह इंगित करना है कि कोड "सख्त मोड" में निष्पादित किया जाना चाहिए।

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

सख्त मोड क्यों?

सख्त मोड "सुरक्षित" जावास्क्रिप्ट लिखना आसान बनाता है।

सख्त मोड में पहले वास्तविक त्रुटियों में "खराब वाक्यविन्यास" स्वीकार किया गया है।

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

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

सख्त मोड में, गैर-लेखन योग्य संपत्ति के लिए कोई असाइनमेंट, एक गेट-केवल संपत्ति, एक गैर-मौजूदा संपत्ति, एक गैर-मौजूदा चर, या एक गैर-मौजूदा ऑब्जेक्ट, एक त्रुटि फेंक देगा।

अधिक जानने के लिए कृपया http://www.w3schools.com/js/js_strict.asp देखें


use strict आपके कोड को सुरक्षित बनाने का एक तरीका है, क्योंकि आप खतरनाक विशेषताओं का उपयोग नहीं कर सकते हैं जो आप उम्मीद नहीं कर सकते हैं। और जैसा कि पहले लिखा गया था, इससे कोड अधिक सख्त हो जाता है।


मेरे दो सेंट:

सख्त मोड के लक्ष्यों में से एक मुद्दों के तेजी से डिबगिंग की अनुमति देना है। यह डेवलपर्स को अपवाद फेंकने में मदद करता है जब कुछ गलत चीजें होती हैं जो आपके वेबपृष्ठ के चुप और अजीब व्यवहार का कारण बन सकती हैं। जिस क्षण हम use strict उपयोग use strict , कोड त्रुटियों को फेंक देगा जो डेवलपर को इसे पहले से ठीक करने में मदद करता है।

use strict उपयोग use strict उपयोग use strict बाद मैंने कुछ महत्वपूर्ण चीजें सीखी हैं:

ग्लोबल वेरिएबल घोषणा रोकता है:

var tree1Data = { name: 'Banana Tree',age: 100,leafCount: 100000};

function Tree(typeOfTree) {
    var age;
    var leafCount;

    age = typeOfTree.age;
    leafCount = typeOfTree.leafCount;
    nameoftree = typeOfTree.name;
};

var tree1 = new Tree(tree1Data);
console.log(window);

अब, यह कोड वैश्विक क्षेत्र में nameoftree बनाता है nameoftree का उपयोग करके एक्सेस किया जा सकता है। जब हम use strict लागू use strict तो कोड त्रुटि फेंक देगा।

Uncaught ReferenceError: nameoftree परिभाषित नहीं है

Sample

कथन के with समाप्त with है:

uglify-js जैसे टूल का उपयोग करके कथन को कम नहीं किया जा सकता है। उन्हें भविष्य में जावास्क्रिप्ट संस्करणों से भी deprecated दिया deprecated और हटा दिया गया है।

Sample

डुप्लिकेट रोकता है:

जब हमारे पास डुप्लिकेट संपत्ति होती है, तो यह अपवाद फेंकता है

Uncaught SyntaxError: सख्त मोड में ऑब्जेक्ट शाब्दिक में डुप्लिकेट डेटा प्रॉपर्टी की अनुमति नहीं है

"use strict";
var tree1Data = {
    name: 'Banana Tree',
    age: 100,
    leafCount: 100000,
    name:'Banana Tree'
};

कुछ और हैं लेकिन मुझे उस पर अधिक ज्ञान हासिल करने की आवश्यकता है।


तुलना करने के लिए छोटा उदाहरण:

गैर-सख्त मोड:

for (i of [1,2,3]) console.log(i)

// output:
// 1
// 2
// 3

सख्त मोड:

'use strict';
for (i of [1,2,3]) console.log(i)

// output:
// Uncaught ReferenceError: i is not defined

सख्त का उपयोग सामान्य और बार-बार त्रुटियों को दिखाने के लिए किया जाता है ताकि इसे अलग-अलग संभाला जा सके और जावा स्क्रिप्ट के तरीके को बदल दिया जा सके, ऐसे परिवर्तन हैं:

  • आकस्मिक ग्लोबल्स रोकता है

  • कोई डुप्लीकेट नहीं

  • के साथ समाप्त होता है

  • इस जबरदस्ती को खत्म करता है

  • सुरक्षित eval ()

  • अपरिवर्तनीय के लिए त्रुटियां

आप विवरण के लिए इस article को भी पढ़ सकते हैं


"सख्त का प्रयोग करें"; एक बीमा है कि प्रोग्रामर जावास्क्रिप्ट के ढीले या खराब गुणों का उपयोग नहीं करेगा। यह एक गाइड है, जैसे एक शासक आपको सीधे लाइन बनाने में मदद करेगा। "सख्त का उपयोग करें" आपको "सीधे कोडिंग" करने में मदद करेगा।

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

मुझ पर विश्वास करो। खराब डिजाइन किए गए कोड की तुलना में ओवरहेड नगण्य है। डॉग क्रॉकफ़ोर्ड, जो कई वर्षों तक एक वरिष्ठ जावास्क्रिप्ट डेवलपर रहा है, यहां एक बहुत ही रोचक पोस्ट है । निजी तौर पर, मैं यह सुनिश्चित करने के लिए हर समय अपनी साइट पर वापस लौटना पसंद करता हूं कि मैं अपना अच्छा अभ्यास नहीं भूलता।

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


आम तौर पर जावा स्क्रिप्ट सख्त नियमों का पालन नहीं करती है इसलिए त्रुटियों की संभावना बढ़ रही है। उपयोग करने के बाद "use strict", जावा स्क्रिप्ट कोड को नियमों के सख्त सेट का पालन करना चाहिए जैसे अन्य प्रोग्रामिंग भाषाओं जैसे कि टर्मिनेटर का उपयोग, प्रारंभिकरण से पहले घोषणा आदि।

यदि "use strict"प्रयोग किया जाता है तो कोड नियमों के सख्त सेट का पालन करके लिखा जाना चाहिए जिससे त्रुटियों और अस्पष्टताओं की संभावना कम हो।


जोड़ते समय "use strict";, स्क्रिप्ट निष्पादित होने से पहले निम्नलिखित मामले SyntaxError फेंक देंगे :

  • भविष्य ECMAScript संस्करणों का मार्ग प्रशस्त , (पूर्वज्ञान में के लिए हाल में सुरक्षित कीवर्ड का उपयोग कर ECMAScript 6 ): implements, interface, let, package, private, protected, public, static, और yield

  • ब्लॉक में समारोह घोषित करना

    if(a<b){ function f(){} }
    
  • ऑक्टल वाक्यविन्यास

    var n = 023;
    
  • this वैश्विक वस्तु को इंगित करें।

     function f() {
          "use strict";
          this.a = 1;
     };
     f(); 
    
  • ऑब्जेक्ट शाब्दिक में किसी संपत्ति नाम के लिए दो बार समान नाम घोषित करना

     {a: 1, b: 3, a: 7} 
    

    यह अब ECMAScript 6 ( बग 1041128 ) में मामला नहीं है ।

  • एक ही नाम समारोह के साथ दो फ़ंक्शन तर्क घोषित करना

    f(a, b, b){}
    
  • एक मान को एक अविकसित चर में सेट करना

    function f(x){
       "use strict";
       var a = 12;
       b = a + x*35; // error!
    }
    f();
    
  • deleteएक चर नाम पर प्रयोग करनाdelete myVariable;

  • उपयोग evalया argumentsपरिवर्तनीय या कार्य तर्क नाम के रूप में

    "use strict";
    arguments++;
    var obj = { set p(arguments) { } };
    try { } catch (arguments) { }
    function arguments() { } 
    

सूत्रों का कहना है:


डेवलपर्स का उपयोग क्यों करना चाहिए मुख्य कारण "use strict"हैं:

  1. वैश्विक चर के आकस्मिक घोषणा को रोकता है । उपयोग "use strict()"करने varसे पहले यह सुनिश्चित होगा कि चर के उपयोग के साथ घोषित किया गया है । उदाहरण के लिए:

    function useStrictDemo(){
     'use strict';
     //works fine
     var a = 'No Problem';
    
     //does not work fine and throws error
     k = "problem"
    
     //even this will throw error
     someObject = {'problem': 'lot of problem'};
    }
    
  2. एनबी: "use strict"निर्देश केवल एक स्क्रिप्ट या एक समारोह की शुरुआत में मान्यता प्राप्त है।
  3. स्ट्रिंग "arguments"को एक चर के रूप में उपयोग नहीं किया जा सकता है:

    "use strict";
    var arguments = 3.14;    // This will cause an error
    
  4. चर के रूप में कीवर्ड के उपयोग प्रतिबंधित करेगा। उनका उपयोग करने की कोशिश करने से त्रुटियां फेंक जाएंगी।

संक्षेप में आपके कोड को कम त्रुटि प्रवण कर देगा और बदले में आप अच्छे कोड लिखेंगे।

इसके बारे में अधिक पढ़ने के लिए आप यहां देख सकते हैं ।


भी शामिल है use strictइस बिंदु से अपने सभी संवेदनशील JavaScript फ़ाइलों की शुरुआत में एक बेहतर जावास्क्रिप्ट प्रोग्रामर हो सकता है और वैश्विक होता जा रहा है और चीजें चुपचाप बदल यादृच्छिक परिवर्तनीय से बचने के लिए एक छोटा सा तरीका है।






use-strict