[javascript] जावास्क्रिप्ट में "कठोर प्रयोग" क्या करता है और इसके पीछे तर्क क्या है?


Answers

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

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

"use strict";

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

Question

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

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

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

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

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




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

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

ईसीएमएस्क्रिप्ट 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 कारण बनता है। इसके अलावा, कुछ कॉलर- और कड़ाई से मोड में फ़ंक्शंस के गुण गुण टाइप करते हैं जब आप उन्हें पढ़ने का प्रयास करते हैं।



There's a good talk by some people who were on the ECMAScript committee: Changes to JavaScript, Part 1: ECMAScript 5" about how incremental use of the "use strict" switch allows JavaScript implementers to clean up a lot of the dangerous features of JavaScript without suddenly breaking every website in the world.

Of course it also talks about just what a lot of those misfeatures are (were) and how ECMAScript 5 fixes them.




When adding "use strict"; , the following cases will throw a SyntaxError before the script is executing:

  • Paving the way for future ECMAScript versions , using one of the newly reserved keywords (in prevision for ECMAScript 6 ): implements , interface , let , package , private , protected , public , static , and yield .

  • Declaring function in blocks

    if(a<b){ function f(){} }
    
  • Octal syntax

    var n = 023;
    
  • this point to the global object.

     function f() {
          "use strict";
          this.a = 1;
     };
     f(); 
    
  • Declaring twice the same name for a property name in an object literal

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

    This is no longer the case in ECMAScript 6 ( bug 1041128 ).

  • Declaring two function arguments with the same name function

    f(a, b, b){}
    
  • Setting a value to an undeclared variable

    function f(x){
       "use strict";
       var a = 12;
       b = a + x*35; // error!
    }
    f();
    
  • Using delete on a variable name delete myVariable;

  • Using eval or arguments as variable or function argument name

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

Sources:




Normally java script does not follow strict rules hence increasing chances of errors. After using "use strict" , the java script code should follow strict set of rules as like in other programming languages such as use of terminators, declaration before initialization etc.

If "use strict" is used then the code should be written by following a strict set of rules hence decreasing the chances of errors and ambiguities.




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



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

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




The main reasons why developers should use "use strict" are:

  1. Prevents accidental declaration of global variables.Using "use strict()" will make sure that variables are declared with var before use. उदाहरण के लिए:

    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. NB: The "use strict" directive is only recognized at the beginning of a script or a function.
  3. The string "arguments" cannot be used as a variable:

    "use strict";
    var arguments = 3.14;    // This will cause an error
    
  4. Will restrict uses of keywords as variables. Trying to use them will throw errors.

In short will make your code less error prone and in turn will make you write good code.

To read more about it you can refer http://www.w3schools.com/js/js_strict.asp .




'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

आगे की पढाई




Just wanted to add some more points.

The Reason to Use Strict Mode--->

  • Strict mode makes it easier to write "secure" JavaScript.

  • Strict mode changes previously accepted "bad syntax" into real
    त्रुटियों।

  • As an example, in normal JavaScript, mistyping a variable name
    creates a new global variable.

  • In strict mode, this will throw an error, making it impossible to accidentally create a global variable.

  • In strict mode, any assignment to a non-writable property, a
    getter-only property, a non-existing property, a non-existing
    variable, or a non-existing object, will throw an error.

The things that will throw errors in Strict Mode Using a variable, without declaring it, is not allowed:

"use strict";
 x = 3.14;                // This will cause an error

Objects are variables too.

Using an object, without declaring it, is not allowed:

  "use strict";
  x = {p1:10, p2:20};      // This will cause an error

Deleting a variable (or object) is not allowed.

  "use strict";
   var x = 3.14;
   delete x;                // This will cause an error

For security reasons, eval() is not allowed to create variables in the scope from which it was called:

"use strict";
 eval ("var x = 2");
 alert (x);               // This will cause an error

फ़ंक्शन कॉल में f (), यह मान वैश्विक ऑब्जेक्ट था। सख्त मोड में, अब यह अपरिभाषित है।

"सख्त उपयोग करें" केवल एक स्क्रिप्ट की शुरुआत में पहचाना जाता है।




"use strict"; is the ECMA effort to make JavaScript a little bit more robust. It brings in JS an attempt to make it at least a little "strict" (other languages implement strict rules since the 90s). It actually "forces" JavaScript developers to follow some sort of coding best practices. Still, JavaScript is very fragile. There is no such thing as typed variables, typed methods, etc. I strongly recommend JavaScript developers to learn a more robust language such as Java or ActionScript3, and implement the same best practices in your JavaScript code, it will work better and be easier to debug.




"Use Strict"; is an insurance that programmer will not use the loose or the bad properties of JavaScript. It is a guide, just like a ruler will help you make straight lines. "Use Strict" will help you do "Straight coding".

Those that prefer not to use rulers to do their lines straight usually end up in those pages asking for others to debug their code.

Believe me. The overhead is negligible compared to poorly designed code. Doug Crockford, who has been a senior JavaScript developer for several years, has a very interesting post here . Personally, I like to return to his site all the time to make sure I don't forget my good practice.

Modern JavaScript practice should always evoke the "Use Strict"; pragma. The only reason that the ECMA Group has made the "Strict" mode optional is to permit less experienced coders access to JavaScript and give then time to adapt to the new and safer coding practices.




Note that use strict was introduced in EcmaScript 5 and was kept since then.

Below are the conditions to trigger strict mode in ES6 and ES7 :

  • Global code is strict mode code if it begins with a Directive Prologue that contains a Use Strict Directive (see 14.1.1).
  • Module code is always strict mode code.
  • All parts of a ClassDeclaration or a ClassExpression are strict mode code.
  • Eval code is strict mode code if it begins with a Directive Prologue that contains a Use Strict Directive or if the call to eval is a direct eval (see 12.3.4.1) that is contained in strict mode code.
  • Function code is strict mode code if the associated FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition, or ArrowFunction is contained in strict mode code or if the code that produces the value of the function's [[ECMAScriptCode]] internal slot begins with a Directive Prologue that contains a Use Strict Directive.
  • Function code that is supplied as the arguments to the built-in Function and Generator constructors is strict mode code if the last argument is a String that when processed is a FunctionBody that begins with a Directive Prologue that contains a Use Strict Directive.



Related