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




syntax jslint use-strict (21)

बयान "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 समर्थित नहीं है

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

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

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

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

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

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


'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

आगे की पढाई


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

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

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

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


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

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


जावास्क्रिप्ट "सख्त" मोड ECMAScript 5 में प्रस्तुत करता है।

  (function() {
  "use strict";
   your code...
   })();

लिखना "सख्त उपयोग करें"; आपकी जेएस फ़ाइल के बहुत ऊपर सख्त वाक्यविन्यास जांच चालू हो जाती है। यह हमारे लिए निम्नलिखित कार्य करता है:

(i) यदि आप एक अविकसित चर को असाइन करने का प्रयास करते हैं तो एक त्रुटि दिखाती है

(ii) आपको कुंजी जेएस सिस्टम पुस्तकालयों को ओवरराइट करने से रोकता है

(ii) कुछ असुरक्षित या त्रुटि-प्रवण भाषा सुविधाओं को रोकता है

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

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


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

बेशक यह भी बात करता है कि उनमें से कितने गलतफहमी हैं (थे) और कैसे ईसीएमएस्क्रिप्ट 5 उन्हें ठीक करता है।


मेरे दो सेंट:

सख्त मोड के लक्ष्यों में से एक मुद्दों के तेजी से डिबगिंग की अनुमति देना है। यह डेवलपर्स को अपवाद फेंकने में मदद करता है जब कुछ गलत चीजें होती हैं जो आपके वेबपृष्ठ के चुप और अजीब व्यवहार का कारण बन सकती हैं। जिस क्षण हम 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'
};

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


जोड़ते समय "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 नहीं करते हैं और मानते हैं कि कोई त्रुटि नहीं है। तो मंथन यह है कि बेहतर कोड लिखने के लिए इस अविश्वसनीय रूप से उपयोगी भाषा सुविधा का उपयोग करना शुरू करने का समय है।

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

var person = {
    name : 'xyz',
    position : 'abc',
    fullname : function () {  "use strict"; return this.name; }
};

JSLint डगलस क्रॉकफोर्ड द्वारा लिखित एक डीबगर है। बस अपनी स्क्रिप्ट में पेस्ट करें, और यह आपके कोड में किसी भी ध्यान देने योग्य मुद्दों और त्रुटियों के लिए जल्दी से स्कैन करेगा।


यह ईसीएमएस्क्रिप्ट 5 की एक नई विशेषता है। जॉन रेसिग ने इसका एक अच्छा सारांश लिखा है।

यह केवल एक स्ट्रिंग है जिसे आपने अपनी जावास्क्रिप्ट फ़ाइलों में रखा है (या तो आपकी फ़ाइल के शीर्ष पर या फ़ंक्शन के अंदर) जो ऐसा लगता है:

"use strict";

इसे अपने कोड में डालने से अब मौजूदा ब्राउज़र के साथ कोई समस्या नहीं होनी चाहिए क्योंकि यह केवल एक स्ट्रिंग है। यदि आपका कोड प्रज्ञा का उल्लंघन करता है तो इससे भविष्य में आपके कोड में समस्याएं हो सकती हैं। उदाहरण के लिए, यदि आपके पास वर्तमान में foo = "bar" , तो पहले foo को परिभाषित किए बिना, आपका कोड विफल हो जाएगा ... जो मेरी राय में एक अच्छी बात है।


जावास्क्रिप्ट सख्त मोड के बारे में यह आलेख आपको रूचि दे सकता है: जॉन रेसिग - ईसीएमएस्क्रिप्ट 5 सख्त मोड, जेएसओएन, और अधिक

कुछ दिलचस्प भागों को उद्धृत करने के लिए:

सख्त मोड ईसीएमएस्क्रिप्ट 5 में एक नई सुविधा है जो आपको "सख्त" ऑपरेटिंग संदर्भ में प्रोग्राम या फ़ंक्शन रखने की अनुमति देती है। यह सख्त संदर्भ कुछ कार्यों को लेने से रोकता है और अधिक अपवाद फेंकता है।

तथा:

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

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

यह भी ध्यान रखें कि आप पूरी फ़ाइल में "सख्त मोड" लागू कर सकते हैं ... या आप इसे केवल एक विशिष्ट फ़ंक्शन के लिए उपयोग कर सकते हैं (अभी भी जॉन रेसिग के आलेख से उद्धरण) :

// Non-strict code...

(function(){
  "use strict";

  // Define your library strictly...
})();

// Non-strict code... 

यदि आपको पुराना और नया कोड मिला है तो कौन सा सहायक हो सकता है ;-)

तो, मुझे लगता है कि यह "use strict" तरह है जो आप पर्ल (इसलिए नाम?) में उपयोग कर सकते हैं: इससे आपको और अधिक चीजों का पता लगाने में मदद मिलती है, जिससे ब्रेकेज हो सकता है।

वर्तमान में, यह सभी प्रमुख ब्राउज़रों (बार आईई 9 और नीचे) द्वारा समर्थित है


यदि लोग 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.
*/

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

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

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

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

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

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

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

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


चेतावनी का एक शब्द, आप सभी हार्ड-चार्जिंग प्रोग्रामर: मौजूदा कोड में "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. वैश्विक चर के आकस्मिक घोषणा को रोकता है । उपयोग "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. चर के रूप में कीवर्ड के उपयोग प्रतिबंधित करेगा। उनका उपयोग करने की कोशिश करने से त्रुटियां फेंक जाएंगी।

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

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


ध्यान दें कि एक्मास्क्रिप्ट 5use strict में पेश किया गया था और तब से रखा गया था।

ES6 और ES7 में सख्त मोड को ट्रिगर करने की शर्तें नीचे दी गई हैं :

  • ग्लोबल कोड सख्त मोड कोड है यदि यह एक निर्देशक प्रस्तावना से शुरू होता है जिसमें उपयोग सख्त निर्देश (14.1.1 देखें) शामिल है।
  • मॉड्यूल कोड हमेशा सख्त मोड कोड है।
  • एक के सभी भागों ClassDeclaration या एक ClassExpression सख्त मोड कोड है।
  • इवल कोड सख्त मोड कोड है यदि यह एक निर्देशक प्रस्तावना से शुरू होता है जिसमें उपयोग सख्त निर्देश शामिल है या यदि कॉल करने के लिए कॉल प्रत्यक्ष eval (12.3.4.1 देखें) है जो सख्त मोड कोड में निहित है।
  • फ़ंक्शन कोड सख्त मोड कोड है यदि संबंधित फ़ंक्शन डिक्लेरेशन, फ़ंक्शनएक्सप्रेस, जेनरेटर डिक्लेरेशन, जेनरेटर एक्स्प्रेशन, मेथडडिफिनिशन, या एरोफंक्शन सख्त मोड कोड में निहित है या यदि कोड जो [[ECMAScriptCode]] आंतरिक स्लॉट के मान का उत्पादन करता है, निर्देशक प्रस्तावना के साथ शुरू होता है जिसमें उपयोग सख्त निर्देश शामिल है।
  • अंतर्निहित फ़ंक्शन और जनरेटर कन्स्ट्रक्टर के तर्क के रूप में प्रदान किया गया फ़ंक्शन कोड सख्त मोड कोड है यदि अंतिम तर्क एक स्ट्रिंग है जो संसाधित होने पर एक फ़ंक्शनबॉडी होता है जो निर्देशक प्रस्तावना से शुरू होता है जिसमें उपयोग सख्त निर्देश होता है।

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


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

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


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

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

"use strict"ईसीएमए 5 में ईसीएमए 5 में इस्तेमाल होने की व्यापक रूप से आवश्यकता है, यह डिफ़ॉल्ट रूप से जावास्क्रिप्ट का हिस्सा है , इसलिए यदि आप ES6 का उपयोग कर रहे हैं तो इसे जोड़ने की आवश्यकता नहीं है।

एमडीएन से इन बयानों और उदाहरणों को देखें:

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

"सख्त उपयोग" का उपयोग करने के उदाहरण:
कार्यों के लिए सख्त मोड: इसी तरह, किसी फ़ंक्शन के लिए सख्त मोड का आह्वान करने के लिए, सटीक कथन "सख्त उपयोग करें" डालें; (या 'सख्त उपयोग करें';) किसी भी अन्य बयान से पहले फंक्शन के शरीर में।

1) कार्यों में सख्त मोड

 function strict() {
     // Function-level strict mode syntax
     'use strict';
     function nested() { return 'And so am I!'; }
     return "Hi!  I'm a strict mode function!  " + nested();
 }
 function notStrict() { return "I'm not strict."; }

 console.log(strict(), notStrict());

2) पूरे स्क्रिप्ट सख्त मोड

'use strict';
var v = "Hi! I'm a strict mode script!";
console.log(v);

3) एक गैर-लेखन योग्य वैश्विक के लिए असाइनमेंट

'use strict';

// Assignment to a non-writable global
var undefined = 5; // throws a TypeError
var Infinity = 5; // throws a TypeError

// Assignment to a non-writable property
var obj1 = {};
Object.defineProperty(obj1, 'x', { value: 42, writable: false });
obj1.x = 9; // throws a TypeError

// Assignment to a getter-only property
var obj2 = { get x() { return 17; } };
obj2.x = 5; // throws a TypeError

// Assignment to a new property on a non-extensible object.
var fixed = {};
Object.preventExtensions(fixed);
fixed.newProp = 'ohai'; // throws a TypeError

आप एमडीएन पर और पढ़ सकते हैं


मैंने अभी यह जावास्क्रिप्ट कोड लिखा है ( DOM मैनिपुलेशन के लिए Prototype का उपयोग करके):

var require = (function() {
    var _required = {};
    return (function(url, callback) {
        if (typeof url == 'object') {
            // We've (hopefully) got an array: time to chain!
            if (url.length > 1) {
                // Load the nth file as soon as everything up to the
                // n-1th one is done.
                require(url.slice(0, url.length - 1), function() {
                    require(url[url.length - 1], callback);
                });
            } else if (url.length == 1) {
                require(url[0], callback);
            }
            return;
        }
        if (typeof _required[url] == 'undefined') {
            // Haven't loaded this URL yet; gogogo!
            _required[url] = [];

            var script = new Element('script', {
                src: url,
                type: 'text/javascript'
            });
            script.observe('load', function() {
                console.log("script " + url + " loaded.");
                _required[url].each(function(cb) {
                    cb.call(); // TODO: does this execute in the right context?
                });
                _required[url] = true;
            });

            $$('head')[0].insert(script);
        } else if (typeof _required[url] == 'boolean') {
            // We already loaded the thing, so go ahead.
            if (callback) {
                callback.call();
            }
            return;
        }

        if (callback) {
            _required[url].push(callback);
        }
    });
})();

उपयोग:

<script src="prototype.js"></script>
<script src="require.js"></script>
<script>
    require(['foo.js','bar.js'], function () {
        /* Use foo.js and bar.js here */
    });
</script>

जिस्ट: http://gist.github.com/284442







javascript syntax jslint use-strict