Was macht "use strict" do, in JavaScript und was ist der Grund dahinter?

StackOverflow https://stackoverflow.com/questions/1335851

Frage

Vor kurzem lief ich einige meiner JavaScript-code durch Crockford ' s JSLint, und es gab den folgenden Fehler:

Problem at line 1 character 1:Missing "use strict" statement.

Tun einige suchen, bemerkte ich, dass einige Leute fügen "use strict"; in Ihren JavaScript-code.Sobald ich fügte hinzu, die Aussage, der Fehler ist gestoppt zu erscheinen.Leider hat Google nicht verraten viel über die Geschichte, die hinter diesem string-Anweisung.Sicherlich muss es etwas damit zu tun haben, wie die JavaScript wird vom browser interpretiert, aber ich habe keine Ahnung, was das bewirken würde.

Also, was ist "use strict"; alles um, was bedeutet es und ist es immer noch relevant?

Führen Sie einen der aktuellen Browser reagieren auf die "use strict"; string-oder ist es für die zukünftige Verwendung?

War es hilfreich?

Lösung

Dieser Artikel über Javascript Strict-Modus könnte Sie interessieren: John Resig - ECMAScript 5 Strict-Modus, JSON und mehr

einige interessante Teile zitieren:

  

Strict-Modus ist ein neues Feature in ECMAScript 5, dass Sie ein Programm platzieren kann oder eine Funktion, in einem „strengen“ Arbeitskontext. Diese strikte Zusammenhang verhindert bestimmte Aktionen aus wird genommen und mehr Ausnahmen auslöst.

Und:

  

Strict-Modus hilft in ein paar Möglichkeiten aus:

     
      
  • Es fängt einige gemeinsame Codierung bloopers, werfen Ausnahmen.
    •   
  • Sie verhindert, oder wirft Fehler, wenn relativ „unsicher“ Maßnahmen ergriffen werden (wie zum Beispiel den Zugriff auf das globale Objekt zu gewinnen).
    •   
  • Es deaktiviert Funktionen, die verwirrend sind oder schlecht durchdacht.
    •   

Beachten Sie auch, können Sie „Strict-Modus“ auf die ganze Datei anwenden ... Oder Sie können es verwenden, nur für eine bestimmte Funktion (noch unter Angabe von John Resig Artikel) : 

// Non-strict code...

(function(){
  "use strict";

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

// Non-strict code...

Welche könnte hilfreich sein, wenn Sie alten und neuen Code zu mischen haben; -)

Also, ich nehme an, es ist ein bisschen wie die "use strict" Sie in Perl verwenden können (daher der Name?): Es hilft Ihnen, weniger Fehler zu machen, um mehr Dinge erkennen, die zu Brüchen führen kann <. / p>

Strict-Modus ist jetzt unterstützt von allen gängigen Browsern .

Innerhalb nativen ECMAScript Module (mit import und export Aussagen) und ES6 Klassen wird Strict-Modus immer aktiviert und kann nicht deaktiviert werden.

Andere Tipps

Es ist eine neue Funktion von ECMAScript 5. John Resig schrieb auf eine schöne Zusammenfassung davon.

Es ist nur eine Zeichenfolge, die Sie in Ihren JavaScript-Dateien setzen (entweder am Anfang der Datei oder innerhalb einer Funktion), die wie folgt aussieht: 

"use strict";

Sie es in Ihrem Code Putting sollte nun keine Probleme mit aktuellen Browsern verursachen, da es nur ein String ist. Es kann Probleme mit Ihrem Code in der Zukunft führen, wenn Ihr Code die pragma verletzt. wenn Sie derzeit haben foo = "bar" zum Beispiel ohne foo definiert Zunächst wird der Code beginnen versagt ... was eine gute Sache meiner Meinung nach ist.

Die Anweisung "use strict"; weist dem browser mit, um den Strict-Modus, das ist ein reduzierter und sicherer Funktion von JavaScript.

Feature-Liste (nicht erschöpfend)

  1. Verbietet die globalen Variablen.(Vermissten var Erklärungen und Tippfehlern in Variablennamen)

  2. Silent fehlerhaften Zuordnungen wirft Fehler im strikten Modus (Zuordnung NaN = 5;)

  3. Versucht zu löschen undeletable Eigenschaften werfen (delete Object.prototype)

  4. Verlangt, dass alle Namen der Eigenschaft in einem Objekt-literal, einzigartig zu sein (var x = {x1: "1", x1: "2"})

  5. Funktion parameter-Namen müssen eindeutig sein (function sum (x, x) {...})

  6. Verbietet oktal syntax (var x = 023; einige devs zu Unrecht davon ausgehen, dass eine vorangegangene null tut nichts, um die Nummer zu ändern.)

  7. Verbietet die with Stichwort

  8. eval im strikten Modus nicht einführen neuer Variablen

  9. Verbietet das löschen von einfachen Namen (delete x;)

  10. Verbietet, die verbindlich oder Zuordnung der Namen eval und arguments in keiner form

  11. Strict-Modus nicht alias-Eigenschaften der arguments Objekt mit der formalen Parameter.(d.h.in function sum (a,b) { return arguments[0] + b;} Dies funktioniert, weil arguments[0] gebunden ist a und so weiter.)

  12. arguments.callee wird nicht unterstützt

[Ref: Strict-Modus, Mozilla Developer Network]

Wenn die Menschen über die Verwendung von use strict besorgt werden könnte es lohnt sich, diesen Artikel sein:

ECMAScript 5 'Strict-Modus' Unterstützung in Browsern. Was heißt das?
   NovoGeek.com - Krishnas Weblog

Er spricht über Browser-Unterstützung, aber noch wichtiger ist, wie man damit umgehen sicher: 

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.
*/

Ein Wort der Vorsicht, alles, was Sie schwer Lade Programmierer: Anwendung "use strict" auf vorhandenen Code kann gefährlich sein! Diese Sache ist nicht irgendein Wohlfühl-, Aufkleber glücklich-Gesicht, dass Sie auf dem Code schlagen kann es ‚besser‘ zu machen. Mit dem "use strict" Pragma, wird der Browser plötzlich Ausnahmen in zufälligen Stellen WERFEN, dass sie warf nie zuvor, nur weil an dieser Stelle Sie etwas tun, dass default / lose JavaScript erlaubt erfreulicherweise aber streng JavaScript verabscheut! Sie können Strikt Verletzungen haben in selten verwendet, um Anrufe in Ihrem Code versteckt, die nur eine Ausnahme auslösen, wenn sie schließlich laufen bekomme - sagen wir, in der Produktionsumgebung, dass Ihre zahlenden Kunden nutzen

Wenn Sie den Sprung zu wagen wollen, ist es eine gute Idee "use strict" neben umfassenden Unit-Tests und eine streng konfiguriert JSHint Build-Task anzuwenden, die Sie etwas Vertrauen geben, dass es keine dunkle Ecke des Moduls ist, die oben wird die Luft sprengen schrecklich, nur weil man auf Strict-Modus aktiviert hat. Oder, hey, hier ist eine andere Option: fügen Sie einfach nicht "use strict" einem Ihrer Legacy-Code, ist es wahrscheinlich sicherer so, ehrlich. DEFINITIV NICHT TUN Add "use strict" auf alle Module, die Sie nicht selbst tun oder erhalten, wie Module von Drittanbietern.

Ich denke, auch wenn es ein tödliches Tier im Käfig ist, "use strict" gutes Material sein kann, aber man muss es richtig machen. Die beste Zeit, streng zu gehen, wenn das Projekt der grünen Wiese ist und Sie von vorne anfangen. Konfigurieren JSHint/JSLint mit allen Warnungen und Optionen angekurbelt so fest wie Ihr Team kann Magen, erhält ein gute build / Test / assert System ich jour wie Grunt+Karma+Chai in Ordnung gebracht, und erst dann beginnt die Kennzeichnung alle Ihre neue Module als "use strict". Seien Sie bereit, viel niggly Fehler und Warnungen zu heilen. Stellen Sie sicher, jeder versteht, die Schwerkraft durch den Build zu FAIL Konfiguration, wenn JSHint/JSLint Verstöße produziert.

Mein Projekt war kein Greenfield-Projekt, als ich "use strict" angenommen. Als Ergebnis ist meine IDE voll von roten Markierungen, weil ich nicht "use strict" auf die Hälfte meiner Module und JSHint beschwert sich darüber. Es ist eine Erinnerung an mich über das, was Refactoring ich in der Zukunft tun soll. Mein Ziel ist es frei rote Markierung aufgrund all meiner fehlenden "use strict" Aussagen zu sein, aber das ist Jahre jetzt weg.

'use strict'; Verwendung nicht plötzlich Ihren Code besser machen.

JavaScript Strict-Modus ist eine Funktion in ECMAScript 5 . Sie können, indem er erklärt dies im Anfang des Skripts / Funktion den Strict-Modus aktivieren. 

'use strict';

Wenn ein JavaScript-Engine sieht diese Richtlinie , wird es beginnen, den Code in einem speziellen Modus zu interpretieren. In diesem Modus werden Fehler ausgelöst, wenn bestimmte Codierung Praktiken, die bis zu werden potenzielle Fehler werden erkannt enden könnten (was die Argumentation hinter dem Strict-Modus ist).

Betrachten Sie dieses Beispiel: 

var a = 365;
var b = 030;

In ihrer Besessenheit, die Zahlenliterale aufreihen, hat der Entwickler versehentlich variable b mit einem Oktal wörtlichen initialisiert. Nicht-Strict-Modus wird mit dem Wert 24 (in der Basis 10) dies als Zahlenliteral interpretieren. Allerdings wird die Strict-Modus einen Fehler aus.

Für eine nicht erschöpfende Liste von Spezialitäten im Strict-Modus finden Sie unter dieser Antwort .

Wo soll ich 'use strict'; verwenden?

  • In meinem neue JavaScript-Anwendung:. Absolut Strict-Modus kann als ein Whistleblower verwendet werden, wenn Sie etwas Dummes mit Ihrem Code tun

  • In meinem vorhandenen JavaScript-Code: Wahrscheinlich nicht Wenn Sie Ihre bestehenden JavaScript-Code-Anweisungen hat, die in streng-Modus verboten sind, wird einfach die Anwendung brechen. Wenn Sie den strikten Modus möchten, sollten Sie zu debuggen und korrigieren Sie Ihre vorhandenen Code vorbereitet. Aus diesem Grunde 'use strict'; mit nicht plötzlich Ihren Code besser machen .

Wie verwende ich Strict-Modus?

  1. Legen Sie eine 'use strict'; Anweisung auf Anfang des Skripts: 

    // File: myscript.js

'use strict';
var a = 2;
....

    Beachten Sie, dass alles, was in der Datei myscript.js wird im Strict-Modus interpretiert werden.

  2. Oder legen Sie eine 'use strict'; Anweisung auf Ihre Funktionskörper: 

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

    Alles in der lexikalischen Gültigkeitsbereich der Funktion doSomething wird im Strict-Modus interpretiert werden. Das Wort lexikalischer Gültigkeitsbereich ist hier wichtig. Siehe diese Antwort für eine bessere Erklärung.

Was die Dinge im Strict-Modus verboten werden?

fand ich einen schönen Artikel beschreibt einige Dinge, die im strikten Modus verboten sind (beachten Sie, dass dies nicht eine exklusive Liste):

  

Anwendungsbereich

     

Historisch gesehen, ist Javascript worden, wie Funktionen verwirrt   sind scoped. Manchmal scheinen sie statisch scoped werden, aber einige   Eigenschaften machen sie verhalten sich wie sie dynamisch scoped sind. Das ist   verwirrend, so dass Programme schwer zu lesen und zu verstehen.   Mißverständnis verursacht Fehler. Es ist auch ein Problem für die Leistung.   Statische Scoping erlauben würde variable Bindung bei der Kompilierung passieren   Zeit, aber die Voraussetzung für den Dynamikumfang bedeutet die Bindung muss sein   latent zu Laufzeit, die mit einer erheblichen Leistungs kommt   Strafe.

     

Strict-Modus erfordert, dass alle Variable statisch erfolgen Bindung.   Das bedeutet, dass die Funktionen, die bisher erforderliche dynamische Bindung   müssen beseitigt oder verändert werden. Insbesondere ist die mit Aussage   eliminiert und die Fähigkeit der Funktion eval mit dem manipulieren   Umgebung seiner Anrufer ist stark eingeschränkt.

     

Einer der Vorteile von strengen Code ist, dass Tools wie YUI Compressor   kann einen besseren Job machen, wenn procEssing es.

     

Implizite Globale Variablen

     

JavaScript hat globale Variablen impliziert. Wenn   Sie nicht explizit eine Variable deklarieren, eine globale Variable ist   implizit für Sie erklärt. Dies erleichtert die Programmierung für   Anfänger, weil sie einen Teil ihres Grund Housekeeping vernachlässigen   Aufgaben. Aber es macht die Verwaltung von größeren Programmen viel mehr   schwierig und es Zuverlässigkeit deutlich verschlechtert. So streng   Modus implizite globale Variablen werden nicht mehr erstellt. Du solltest   ausdrücklich alle Ihre Variablen deklarieren.

     

Globale Leakage

     

Es gibt eine Reihe von Situationen, die dazu führen könnten, this   gebunden an das globale Objekt werden. Wenn Sie zum Beispiel, vergessen   bieten die new Präfix, wenn eine Konstruktor-Funktion aufrufen, die   Konstruktor this wird unerwartet auf das globale Objekt gebunden werden, so   stattdessen ein neues Objekt zu initialisieren, wird es stattdessen still sein   Manipulation mit globalen Variablen. In diesen Situationen strenger Modus   stattdessen binden this zu undefined, die den Konstruktor verursachen   werfen, anstatt eine Ausnahme, den Fehler so dass viel zu erfassende   früher.

     

Laut Failure

     

JavaScript ist immer schreibgeschützte Eigenschaften hatte, aber Sie   kann sie nicht selbst bis ES5 den Object.createProperty erstellen   Funktion ausgesetzt diese Fähigkeit. Wenn Sie versucht, einen Wert zuzuweisen   auf eine schreibgeschützte Eigenschaft, wäre es unbemerkt fehlschlagen. Die Zuordnung würde   nicht den Wert der Eigenschaft ändern, aber Ihr Programm würde vorgehen   obwohl es hatte. Dies ist eine Integrität Gefährdung, die dazu führen können Programme   gehen in einem inkonsistenten Zustand. Im strikten Modus versuchen, eine ändern   Nur-Lese-Eigenschaft wird eine Ausnahme werfen.

     

Octal

     

Das oktale (oder Basis 8) Darstellung von Zahlen war äußerst   nützlich, wenn auf Maschinen, deren Wort Maschine-Level-Programmierung zu tun   Größen waren ein Vielfaches von 3. Sie Oktal benötigt, wenn mit dem CDC arbeiten   6600-Mainframe, die eine Wortgrße von 60 Bit hat. Wenn Sie könnten lesen   Oktal Sie auf ein Wort als 20 Ziffern aussehen könnte. Zwei Ziffern dargestellt   der OP-Code, und eine Ziffer identifiziert eines von 8-Register. Während der   langsamer Übergang von Maschinencodes auf Hochsprachen, war es   Oktal Formen gedacht, um nützlich seine Sprache bei der Programmierung zur Verfügung zu stellen.

     

In C, eine äußerst unglückliche Darstellung octalness war   ausgewählt: Null Führende. So in C bedeutet 0100 64, nicht 100, und 08 ist ein   Fehler, nicht 8. Noch leider hat sich diese Anachronismus gewesen   in fast allen modernen Sprachen kopiert, einschließlich JavaScript, wo   es wird nur verwendet, um Fehler zu erstellen. Es hat keinen anderen Zweck. so in   Strict-Modus sind Oktal Formen nicht mehr erlaubt.

     

Et cetera

     

Die Argumente Pseudo-Array wird ein bisschen mehr   arrayförmig in ES5. Im strikten Modus verliert es seine callee und caller   Eigenschaften. Dies macht es möglich, Ihre arguments nicht vertrauenswürdigen passieren   Code ohne viele vertraulichen Kontext aufzugeben. Auch der   arguments Eigenschaft von Funktionen eliminiert wird.

     

Im strikten Modus doppelte Schlüssel in einem Funktionsliteral produzieren ein   Syntax-Fehler. Eine Funktion kann nicht zwei Parameter mit dem gleichen Namen.   Eine Funktion kann nicht eine Variable mit dem gleichen Namen haben als eine ihrer   Parameter. Eine Funktion kann nicht seine eigenen Variablen delete. Ein Versuch zu   delete eine nicht-konfigurierbare Eigenschaft jetzt eine Ausnahme auslöst. Primitive   Werte werden nicht implizit gewickelt.

Reservierte Wörter für zukünftige JavaScript-Versionen

ECMAScript 5 fügt eine Liste der reservierten Wörter. Wenn Sie sie als Variablen oder Argumente verwenden, wird der Strict-Modus einen Fehler aus. Die reservierten Worte sind:

  

implements, interface, let, package, private, protected, public, static und yield

Weiterführende Literatur

Ich empfehle jeden Entwickler nun mit striktem Modus zu starten. Es gibt genug Browser, dass strenger Modus unterstützt wird berechtigterweise Hilfe rettet uns von Fehlern, die wir nicht einmal wissen, in Ihrem Code ist.

Offenbar in der Anfangsphase kommt es zu Fehlern, die wir noch nie zuvor erlebt haben. Um den vollen Nutzen zu erhalten, müssen wir die richtigen Tests tun nach strengem Modus Schalten sicherzustellen, dass wir gefangen haben alles. Auf jeden Fall haben wir nicht nur use strict in unserem Code werfen und annehmen, dass es keine Fehler gibt. So ist die Abwanderungs ist, dass es an der Zeit mit dieser unglaublich nützlichen Sprache-Funktion zu starten besseren Code zu schreiben.

Beispiel: 

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

JSLint ist ein Debugger von Douglas Crockford geschrieben. Einfach in Ihrem Skript einfügen, und es wird für irgendwelche wahrnehmbaren Probleme und Fehler im Code schnell scannen.

Ich mag eine etwas gegründete Antwort bieten, die anderen Antworten ergänzen. Ich hatte gehofft, die populärste Antwort zu bearbeiten, scheiterte aber. Ich habe versucht, es so umfassend zu machen und vollständig wie ich kann.

können Sie beziehen sich auf die MDN Dokumentation für weitere Informationen.

"use strict" eine Richtlinie eingeführt in ECMAScript 5.

Richtlinien sind ähnlich wie Aussagen, noch anders aus.

  • use strict enthält keine Schlüsselwörter: Die Richtlinie ist eine einfache Ausdruck Aussage, die aus einem speziellen Stringliteral besteht (in einfachen oder doppelten Anführungszeichen). JavaScript-Engine, die nicht implementieren ECMAScript 5, lediglich einen Ausdruck Aussage ohne Nebenwirkungen sehen. Es wird erwartet, dass zukünftige Versionen von ECMAScript-Standards use als echtes Schlüsselwort einzuführen; die Anführungszeichen würde damit obsolet geworden.
  • use strict kann nur am Anfang eines Skripts oder eine Funktion verwendet werden, das heißt es jede andere (real) Erklärung vorangestellt werden muss. Es muss nicht die erste Anweisung in einem Skript von Funktion sein: es kann durch andere Erklärung Ausdrücke vorangestellt werden, die von Stringliterale bestehen (und JavaScript-Implementierungen können sie als Umsetzung spezifischer Richtlinien behandeln). Stringliterale Aussagen, die eine erste wirkliche Erklärung folgen (in einem Skript oder Funktion) sind einfacher Ausdruck Aussagen. Dolmetscher müssen sie als Richtlinien nicht interpretieren und sie haben keine Wirkung.

Die use strict Direktive gibt an, dass der folgenden Code (in einem Skript oder eine Funktion) strenger Code. Der Code in der höchsten Ebene eines Skripts (Code, der nicht in einer Funktion) wird streng Code betrachtet, wenn das Skript eine use strict Direktive enthält. Der Inhalt einer Funktion wird strenger Code betrachtet, wenn die Funktion selbst in einem strengen Code definiert ist, oder wenn die Funktion enthält eine use strict Richtlinie. Code, der auf eine eval() Methode übergeben wird, wird streng Code betrachtet, wenn eval() von einem strengen Code oder enthält die use strict Richtlinie selbst genannt wurde.

Der Strict-Modus von ECMAScript 5 ist eine eingeschränkte Teilmenge der Sprache JavaScript, um die relevanten Defizite der Sprache beseitigt und verfügt über strengere Fehlerprüfung und höhere Sicherheit. Im Folgenden werden die Unterschiede zwischen strengen und dem normalen Modus (von denen die ersten drei sind besonders wichtig):

  • Sie können nicht die with-Anweisung im strikten Modus verwenden.
  • In Strict-Modus alle Variablen deklariert werden: wenn Sie einen Wert auf eine Kennung zuweisen, die nicht als Variable, Funktion, Funktionsparameter, catch-Klausel Parameter oder eine Eigenschaft des globalen Object erklärt hat, dann werden Sie eine bekommen ReferenceError. Im Normalbetrieb wird die Kennung implizit als globaler Variable (als Eigenschaft des globalen Object)
    • erklärt
  • In Strict-Modus das Schlüsselwort this den Wert undefined in Funktionen, die als Funktionen (nicht als Methoden) aufgerufen wurden. (Im Normalmodus this zeigt immer auf den globalen Object). Dieser Unterschied kann zu Test verwendet werden, wenn eine Implementierung des Strict-Modus unterstützt: 
var hasStrictMode = (function() { "use strict"; return this===undefined }());

  • Auch wenn eine Funktion mit call() oder apply im Strict-Modus aufgerufen wird, dann ist this genau der Wert des ersten Arguments des call()or apply() Aufrufs. (Im Normalmodus null und undefined werden durch die globale Object ersetzt und Werte, die nicht sind Objekte, werden in Objekte gegossen.)

  • In Strict-Modus erhalten Sie eine TypeError erhalten, wenn Sie versuchen, Nur-Lese-Eigenschaften zuweisen oder ne zu definierenw Eigenschaften für ein nicht erweiterbares Objekt. (Im Normalbetrieb beide einfach nicht ohne Fehlermeldung.)

  • Im strikten Modus, wenn der Code auf eval() geben, können Sie nicht deklarieren oder definieren Variablen oder Funktionen im Rahmen des Anrufers (wie Sie es im normalen Modus tun können). Stattdessen wird ein neuer Rahmen für eval() erstellt und die Variablen und Funktionen sind in diesem Umfang. Das Rahmen wird zerstört, nachdem eval() beendet Ausführung.
  • In Strict-Modus die Argumente-Objekt einer Funktion enthält eine statische Kopie der Werte, die zu dieser Funktion übergeben werden. Im Normalbetrieb hat das Argumente-Objekt ein etwas „magisches“ Verhalten. Die Elemente des Arrays, und die genannten Funktionsparameter verweisen beide den gleichen Wert
  • In Strict-Modus Sie eine SyntaxError erhalten werden, wenn der delete Operator durch eine nicht qualifizierte Kennung (eine Variable, Funktion oder Funktionsparameter) folgen. Im Normalbetrieb würde der delete Ausdruck nichts tun und auf false ausgewertet.
  • In Strict-Modus Sie eine TypeError erhalten, wenn Sie versuchen, eine nicht konfigurierbare Eigenschaft zu löschen. (Im Normalbetrieb der Versuch einfach ausfällt und der delete Ausdruck zu false ausgewertet).
  • In Strict-Modus wird ein syntaktischer Fehler angesehen, wenn Sie versuchen, für ein Objekt wörtlichen mehr Objekte mit dem gleichen Namen zu definieren. (Im Normalbetrieb gibt es keine Fehler.)
  • In Strict-Modus wird ein syntaktischer Fehler angesehen, wenn eine Funktionsdeklaration mehrere Parameter mit dem gleichen Namen hat. (Im Normalbetrieb gibt es keine Fehler.)
  • Im strikten Modus Oktal Literale nicht erlaubt sind (diese Literale sind, die mit 0x starten. (Im normalen Modus einige Implementierungen erlauben Oktal Literale.)
  • In Strict-Modus die Kennungen eval und arguments sind wie Schlüsselwörter behandelt. Sie können ihren Wert nicht ändern, können keinen Wert zuweisen, und Sie können sie nicht für Variablen als Namen verwenden, Funktionen, Funktionsparameter oder Bezeichner eines catch-Block.
  • In Strict-Modus sind weitere Einschränkungen der Möglichkeiten des Call-Stack zu untersuchen. arguments.caller und arguments.callee Ursache einer TypeError in einer Funktion im Strict-Modus. Darüber hinaus wurden einige anrufer- und Argumente Eigenschaften von Funktionen im strikten Modus Ursache einer TypeError wenn Sie versuchen, sie zu lesen.

Meine zwei Cent:

Eines der Ziele des Strict-Modus ist für eine schnellere Fehlersuche von Problemen zu ermöglichen. Es hilft, die Entwicklern von Ausnahme auszulösen, wenn bestimmte Dinge falsch vorkommen, dass stilles & seltsames Verhalten Ihrer Webseite führen kann. In dem Moment, wir use strict verwenden, wird der Codefehler werfen die Entwickler es im Voraus zu beheben hilft.

Ein paar wichtige Dinge, die ich nach der Verwendung von use strict gelernt haben:

Verhindert, dass globale Variable Deklaration: 

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);

Jetzt erstellt dieser Code nameoftree in globalem Bereich, die mit window.nameoftree zugegriffen werden können. Wenn wir use strict der Code implementieren würde Fehler werfen.

  

Uncaught Reference: nameoftree ist nicht definiert

Beispiel

Eliminieren with Anweisung:

with Anweisungen können nicht minimierte werden mit Tools wie uglify-js . Sie sind auch deprecated und von zukünftigen JavaScript-Versionen entfernt.

Beispiel

Verhindert, dass Dubletten:

Wenn wir doppelte Eigenschaft haben, wirft es eine Ausnahme

  

Uncaught Syntax: Doppelte Dateneigenschaft in Objektliteral nicht   im Strict-Modus erlaubt 

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

Es gibt einige mehr, aber ich brauche, um mehr Wissen über das zu gewinnen.

Wenn Sie einen Browser im letzten Jahr veröffentlicht oder so dann ist es höchstwahrscheinlich unterstützt JavaScript Strict-Modus. Nur älterer Browser um vor ECMAScript 5 wurde der aktuelle Standard nicht unterstützen.

Die Anführungszeichen um den Befehl stellen Sie sicher, dass der Code noch Arbeit in älteren Browsern als auch (obwohl die Dinge, die einen Syntaxfehler in der Strict-Modus erzeugen werden in der Regel nur weil das Skript zu Fehlfunktionen in einigen harten Art und Weise in diesen älteren zu erkennen Browser).

Wenn "use strict"; Hinzufügen folgende Fälle wird ein werfen Syntax , bevor das Skript ausgeführt wird:

  • ebnet den Weg für zukünftige ECMAScript Versionen , mit einem der neu reservierten Schlüsselwörter (in prevision für ECMAScript 6 ): implements, interface, let, package , private, protected, public, static und yield.

  • Deklarieren Funktion in Blöcken 

    if(a<b){ function f(){} }

  • Octal Syntax 

    var n = 023;

  • this Punkt auf das globale Objekt. 

     function f() {
      "use strict";
      this.a = 1;
 };
 f();

  • Deklarieren zweimal den gleichen Namen für einen Eigenschaftsnamen in einem Objektliteral 

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

    Dies ist nicht mehr der Fall in ECMAScript 6 ( Bug 1.041.128 ).

  • Deklarieren von zwei Funktionsargumente mit dem gleichen Namen Funktion 

    f(a, b, b){}

  • Wert auf eine nicht deklarierte Variable Einstellung 

    function f(x){
   "use strict";
   var a = 12;
   b = a + x*35; // error!
}
f();

  • Mit delete auf einem Variablennamen delete myVariable;

  • Mit eval oder arguments als Variable oder Funktionsargument Name 

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

Quellen:

Strict-Modus macht einige Änderungen an normaler JavaScript Semantik:

  • beseitigt einige JavaScript stille Fehler, die durch sie zu ändern Fehler zu werfen.

  • behebt Fehler, die es schwierig für JavaScript machen Motoren Optimierungen durchzuführen.

  • verbietet einige Syntax wahrscheinlich in Zukunft definiert werden Versionen von ECMAScript.

Für mehr Informationen vistit Strict Modus- Javascript

"use strict"; ist eine Versicherung, dass Programmierer nicht die losen oder die schlechten Eigenschaften von JavaScript verwenden. Es ist eine Anleitung, wie ein Lineal Sie gerade Linien optimal nutzen können. "Use strict" helfen Sie "Straight-Codierung".

Diejenigen, die nicht zu verwenden Lineale es vorziehen, ihre Linien gerade in der Regel zu tun, für andere zu fragen in diesen Seiten am Ende ihren Code zu debuggen.

Glauben Sie mir. Der Aufwand ist vernachlässigbar im Vergleich zu schlecht konzipiert Code. Doug Crockford, die ein Senior war JavaScript-Entwickler für mehrere Jahre, hat einen sehr interessanten Beitrag hier . Persönlich mag ich die ganze Zeit an seiner Seite zurückzukehren sicherzustellen, dass ich nicht vergessen, meine gute Praxis.

Moderne JavaScript Praxis sollte immer erinnern an die "use strict"; Pragma. Der einzige Grund, dass die ECMA-Gruppe die „Strenge“ Modus optional gemacht hat, ist weniger erfahrene Programmierer Zugriff auf JavaScript zu ermöglichen, und geben Sie dann Zeit, um die neuen und sichereren Codierungspraktiken anzupassen.

Einschließlich use strict am Anfang Ihrer alle sensiblen JavaScript-Dateien von diesem Punkt ist ein kleiner Weg, um einen besseren JavaScript-Programmierer und vermeiden Zufallsvariablen werden immer globaler und Dinge still zu ändern.

Zitiert von w3schools :

  

Die "use strict" Richtlinie

     

Die "use strict" Richtlinie ist neu in JavaScript 1.8.5 (ECMAScript   Version 5).

     

Es ist keine Aussage, sondern ein wörtlicher Ausdruck, von früher ignoriert   Versionen von JavaScript.

     

Der Zweck von „use strict“ ist, um anzuzeigen, dass der Code sein sollte   in "Strict-Modus" ausgeführt.

     

Mit strengem Modus können Sie zum Beispiel nicht, verwenden Sie nicht deklarieren Variablen.

     

Warum Strict Mode?

     

Strict-Modus macht es leichter zu schreiben "sicheren" JavaScript.

     

Strict-Modus ändert sich zuvor akzeptiert "schlechte Syntax" in echte Fehler.

     

Als Beispiel in normalen JavaScript, um einen Variablennamen Vertippen schafft   eine neue globale Variable. Im strikten Modus wird dies einen Fehler aus,   was es unmöglich macht aus Versehen eine globale Variable erstellen.

     

Im normalen JavaScript wird ein Entwickler erhalten keine Fehler Feedback   Zuweisen von Werten zu nicht beschreibbaren Eigenschaften.

     

Im strikten Modus jede Zuordnung zu einer nicht beschreibbaren Eigenschaft, ein   Getter-only Eigenschaft, eine nicht vorhandene Eigenschaft, eine nicht vorhandene   Variable oder ein nicht vorhandenes Objekt, wird einen Fehler werfen.

Bitte beachten Sie http://www.w3schools.com/js/js_strict.asp um mehr zu erfahren

"use strict" macht JavaScript-Code läuft in Strict-Modus , was bedeutet im Grunde alles, was Bedürfnisse vor der Verwendung definiert werden. Der Hauptgrund für die Verwendung von striktem Modus ist zufällig globale Verwendungen von undefinierten Methoden zu vermeiden.

Auch im strikten Modus, Dinge schneller zu laufen, einige Warnungen oder stille Warnungen werfen schwerwiegende Fehler, es ist besser, immer es zu verwenden, um eine sauberere Code zu machen.

"use strict" ist weit erforderlich, um in ECMA5 verwendet werden, in ECMA6 Es ist ein Teil von JavaScript standardmäßig , so braucht es nicht hinzugefügt werden, wenn Sie ES6 verwenden.

Sehen sie sich diese Aussagen und Beispiele von MDN:

  

Die "use strict" Richtlinie
Die Richtlinie neu in ist "use strict"   JavaScript 1.8.5 (ECMAScript Version 5). Es ist keine Aussage, sondern ein   wörtlicher Ausdruck, die von früheren Versionen von JavaScript ignoriert. Das   Zweck der „use strict“ ist, um anzuzeigen, dass der Code sein sollte   in "Strict-Modus" ausgeführt. Mit strengem Modus können Sie zum Beispiel nicht,   Verwendung der nicht angemeldete Variablen.

     

Beispiele für die Verwendung "use strict":
  Strict-Modus für Funktionen: Ebenso strengen Modus für eine aufrufen   Funktion, legen Sie die genaue Aussage „use strict“; (Oder 'Verwendung streng';) in   die körpereigene Funktion vor allen anderen Anweisungen.

1) Strict-Modus in den Funktionen 

 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) Ganz Skript Strict-Modus 

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

3) Zuordnung zu einem nicht beschreibbaren globalen 

'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

Sie können lesen Sie mehr auf MDN .

Es gibt ein gutes Gespräch von einigen Leuten, die auf dem ECMAScript Ausschuß waren: Änderungen an JavaScript, Teil 1 :. ECMAScript 5" wie inkrementelle Verwendung des "use strict" Switch ermöglicht Implementierer JavaScript viele der gefährlichen Eigenschaften von JavaScript, um aufzuräumen, ohne plötzlich jede Website in der Welt zu brechen

Natürlich ist es spricht auch über genau das, was viele dieser Fehlentwicklungen vermeiden sind (waren) und wie ECMAScript 5 behebt sie.

Kleine Beispiele zum Vergleich:

Nicht-Strict-Modus: 

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

Strict-Modus: 

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

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

Nicht-Strict-Modus: 

String.prototype.test = function () {
  console.log(typeof this === 'string');
};

'a'.test();

// output
// false

String.prototype.test = function () {
  'use strict';
  
  console.log(typeof this === 'string');
};

'a'.test();

// output
// true

Beachten Sie, dass use strict eingeführt wurde, in EcmaScript 5 und wurde seitdem gehalten.

Im Folgenden sind die Bedingungen Strict-Modus auszulösen in ES6 und ES7 :

  
      
  • Globaler Code ist Strict-Modus-Code, wenn es mit einer Richtlinie Prolog beginnt, die eine Verwendung strenge Richtlinie enthält (siehe 14.1.1).
    •   
  • Code-Modul ist immer Strict-Modus-Code.
    •   
  • Alle Teile einer ClassDeclaration oder ClassExpression ist Strict-Modus-Code.
    •   
  • Eval-Code ist Strict-Modus-Code, wenn es mit einer Richtlinie Prolog beginnt, die eine Verwendung strenge Richtlinie enthält oder ob der Aufruf eval ist eine direkte eval (siehe 12.3.4.1), die im strengen Modus-Code enthalten ist.
    •   
  • Funktionscode ist streng Code-Modus, wenn die zugehörigen FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition oder ArrowFunction im Strict-Modus-Code enthalten ist, oder wenn der Code, der den Wert der Funktion des erzeugt [[ ECMAScriptCode]] interner Steckplatz beginnt mit einer Richtlinie Prolog, die eine Verwendung strenge Richtlinie enthält.
    •   
  • Funktionscode, wie die Argumente für den eingebauten Funktion und Generator Bauer zugeführt wird, Strict-Modus-Code, wenn das letzte Argument ein String ist, dass bei der Verarbeitung eines FunctionBody , die mit einer Richtlinie Prolog beginnt das enthält eine Verwendung strenge Richtlinie.
    •   

Die wichtigsten Gründe, warum Entwickler "use strict" verwenden sollten, sind:

  1. Verhindern versehentliche Erklärung globaler variables.Using "use strict()" wird sicherstellen, dass Variablen mit var vor der Verwendung deklariert werden. Zum Beispiel: 

    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. N. B:. Die "use strict" Richtlinie erst am Anfang eines Skripts oder eine Funktion erkannt wird

  3. Der String "arguments" kann nicht als Variable verwendet werden: 

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

  4. Wird Verwendung von Keywords als Variablen beschränken. Der Versuch, sie zu benutzen, werden Fehler werfen.

Kurz gesagt wird Ihren Code weniger fehleranfällig und wiederum machen werden Sie guten Code schreiben.

mehr erfahren können Sie verweisen hier .

"use strict"; JavaScript ein bisschen robuster zu machen, ist der ECMA Aufwand. Es bringt in JS einen Versuch zu machen, zumindest ein wenig „streng“ (weitere Sprachen implementieren strenge Regeln seit den 90er Jahren). Es „zwingt“ eigentlich JavaScript-Entwickler eine Art von Codierung Best Practices zu folgen. Dennoch ist JavaScript sehr instabil. Es gibt nicht so etwas wie typisierte Variablen, typisierte Methoden usw. Ich JavaScript-Entwickler empfehle eine robustere Sprache wie Java oder ActionScript3 stark, zu lernen und die gleiche Best Practices in Ihrem JavaScript-Code zu implementieren, es wird besser funktionieren und einfacher zu debuggen sein.

JavaScript „streng“ -Modus in ECMAScript 5 eingeführt wurde. 

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

Das Schreiben "use strict"; an der Spitze Ihrer JS-Datei schaltet streng Syntaxprüfung. Es führt die folgenden Aufgaben für uns:

  1. zeigt einen Fehler, wenn Sie versuchen, eine nicht deklarierte Variable

    2. zuweisen

  2. hindert Sie daran, zu überschreiben Schlüssel JS Systembibliotheken

  3. verbietet einige unsichere oder fehleranfällige Sprachfeatures

use strict funktioniert auch innerhalb der einzelnen Funktionen. Es ist immer eine bessere Praxis use strict im Code enthalten.

Browser Kompatibilitätsproblem: Die „Verwendung“ Richtlinien sollen rückwärtskompatibel sein. Browser, die sie nicht unterstützen, wird nur ein Stringliteral sehen, die nicht weiter verwiesen wird. So werden sie über sie passieren und weitergehen.

use strict ist ein Weg, um Ihren Code sicherer zu machen, weil du nicht gefährliche Funktionen verwenden können, die nicht arbeiten können, wie Sie expect.and als writed wurde, bevor es Code strenger macht.

Mit Strenge verwendet wird gemeinsam zu zeigen und Fehler wiederholt, so dass es anders gehandhabt wird, und ändert die Art und Weise Java-Script ausgeführt wird, solche Änderungen sind:

  • Verhindert versehentliche Globals

  • Keine Duplikate

  • Eliminiert mit

  • Beseitigt diese Nötigung

  • Safer eval ()

  • Fehler für immutables

Sie können auch diese Artikel für die Details

Normalerweise JavaScript folgt nicht strenge Regeln, damit die Chancen von Fehlern zu erhöhen. Nach der Verwendung von "use strict" sollte der JavaScript-Code strenge Regeln wie in anderen Programmiersprachen folgen, wie die Verwendung von Terminator, Erklärung vor der Initialisierung, usw.

Wenn "use strict" verwendet wird, soll der Code durch Anschluss an eine Reihe von strengen Regeln geschrieben werden, damit die Chancen auf Fehler und Unklarheiten zu verringern.

"use strict"; Legt fest, dass JavaScript-Code sollte in ausgeführt werden    "Strict-Modus".

  • Die "use strict" Richtlinie war neu in ECMAScript Version 5.
  • Es ist keine Aussage, sondern ein wörtlicher Ausdruck, von früher ignoriert Versionen von JavaScript.
  • Der Zweck der „use strict“ ist, um anzuzeigen, dass der Code sein sollte in "Strict-Modus" ausgeführt.
  • Mit strengem Modus können Sie zum Beispiel nicht, verwenden Sie nicht angemeldete Variablen.

Alle modernen Browser unterstützen "use strict" mit Ausnahme von Internet Explorer 9 und senken .

Nachteil

Wenn ein Entwickler eine Bibliothek verwendet, die im strikten Modus war, aber der Entwickler verwendet wurde, im normalen Modus zu arbeiten, könnten sie einige Aktionen auf der Bibliothek aufrufen, die nicht wie erwartet funktionieren würde.

Schlimmer noch, da der Entwickler im Normalmodus ist, sie haben nicht die Vorteile der zusätzlichen Fehler ausgelöst werden, so dass der Fehler unbemerkt fehlschlagen könnte.

Auch, wie oben aufgeführt, Strict-Modus hält, von Ihnen bestimmte Dinge zu tun.

Die Menschen im Allgemeinen denken, dass Sie diese Dinge nicht in erster Linie verwendet werden sollen, aber einige Entwickler nicht wie die Einschränkung und wollen alle die Eigenschaften der Sprache verwenden.

Strict-Modus können Speicherlecks verhindern.

Bitte überprüfen Sie die Funktion unten geschrieben in Nicht-Strict-Modus: 

function getname(){
    name = "Stack Overflow"; // Not using var keyword
    return name;
}
getname();
console.log(name); // Stack Overflow

In dieser Funktion verwenden wir eine Variable name innerhalb der Funktion genannt. Intern prüfen wird der Compiler zunächst, ob es eine Variable mit diesem besonderen Namen in diesem speziellen Funktion Gültigkeitsbereich deklariert ist. Da der Compiler versteht sich, dass es keine solche Variable ist, wird es in dem äußeren Umfang überprüfen. In unserem Fall ist es die globale Reichweite. Auch hier versteht der Compiler, dass es auch mit diesem Namen in dem globalen Raum deklariert keine Variable ist, so ist es für uns im globalen Raum, wie eine Variable erzeugt. Konzeptionell diese Variable im globalen Bereich erstellt wird und wird in der gesamten Anwendung zur Verfügung.

Ein weiteres Szenario ist, dass, sagen wir, die Variable in einer untergeordneten Funktion deklariert. In diesem Fall kann der Compiler prüft die Gültigkeit dieser Variablen in dem äußeren Umfang, das heißt, die übergeordnete Funktion. Erst dann wird es im globalen Raum überprüfen und eine Variable für uns dort erstellen. Das bedeutet, dass zusätzliche Kontrollen müssen durchgeführt werden. Dadurch wird die Leistung der Anwendung auswirken.

Lassen Sie uns jetzt die gleiche Funktion im Strict-Modus schreiben. 

"use strict"
function getname(){
    name = "Stack Overflow"; // Not using var keyword
    return name;
}
getname();
console.log(name);

Wir werden die folgende Fehlermeldung erhalten. 

Uncaught ReferenceError: name is not defined
at getname (<anonymous>:3:15)
at <anonymous>:6:5

Hier führt der Compiler den Referenzfehler. In Strict-Modus, wird der Compiler uns nicht erlauben, um die Variable zu verwenden, ohne sie zu erklären. So Speicherlecks verhindert werden. Darüber hinaus können wir mehr optimierten Code schreiben.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top