Kürzlich habe ich einen Teil meines JavaScript-Codes über Crockfords JSLint ausgeführt und dabei den folgenden Fehler ausgegeben:

Problem in Zeile 1, Zeichen 1: Fehlende Anweisung "use strict".

Beim Suchen wurde mir klar, dass einige Leute "use strict";ihren JavaScript-Code ergänzen . Nachdem ich die Anweisung hinzugefügt hatte, wurde der Fehler nicht mehr angezeigt. Leider hat Google nicht viel von der Geschichte hinter dieser Zeichenfolgenanweisung enthüllt. Natürlich muss es etwas damit zu tun haben, wie das JavaScript vom Browser interpretiert wird, aber ich habe keine Ahnung, wie sich das auswirken würde.

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

Reagiert einer der aktuellen Browser auf die "use strict";Zeichenfolge oder ist er für die zukünftige Verwendung vorgesehen?

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

Um einige interessante Teile zu zitieren:

Der strikte Modus ist eine neue Funktion in ECMAScript 5, mit der Sie ein Programm oder eine Funktion in einen "strengen" Betriebskontext stellen können. Dieser strenge Kontext verhindert, dass bestimmte Aktionen ausgeführt werden, und löst weitere Ausnahmen aus.

Und:

Der strenge Modus hilft auf verschiedene Arten:

• Es fängt einige gängige Codierungsfehler ein und löst Ausnahmen aus.
• Es verhindert oder löst Fehler aus, wenn relativ "unsichere" Aktionen ausgeführt werden (z. B. Zugriff auf das globale Objekt).
• Es deaktiviert Funktionen, die verwirrend oder schlecht durchdacht sind.

Beachten Sie auch, dass Sie den "strengen Modus" auf die gesamte Datei anwenden können ... Oder Sie können ihn nur für eine bestimmte Funktion verwenden (zitiert immer noch aus John Resigs Artikel) :

// Non-strict code...

(function(){
  "use strict";

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

// Non-strict code... 

Was hilfreich sein kann, wenn Sie alten und neuen Code mischen müssen ;-)

Ich nehme an, es ist ein bisschen wie das, was "use strict"Sie in Perl verwenden können (daher der Name?) : Es hilft Ihnen, weniger Fehler zu machen, indem es mehr Dinge erkennt, die zu Brüchen führen können.

Der strikte Modus wird jetzt von allen gängigen Browsern unterstützt .

In nativen ECMAScript-Modulen (mit importund exportAnweisungen) und ES6-Klassen ist der strikte Modus immer aktiviert und kann nicht deaktiviert werden.

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

Es ist nur eine Zeichenfolge, die Sie in Ihre JavaScript-Dateien einfügen (entweder oben in Ihrer Datei oder innerhalb einer Funktion) und die folgendermaßen aussieht:

"use strict";

Das Einfügen in Ihren Code sollte bei aktuellen Browsern keine Probleme verursachen, da es sich nur um eine Zeichenfolge handelt. Es kann in Zukunft Probleme mit Ihrem Code verursachen, wenn Ihr Code das Pragma verletzt. Wenn Sie zum Beispiel derzeit keine foo = "bar"Definition haben, schlägt fooIhr Code fehl ... was meiner Meinung nach eine gute Sache ist.

Die Anweisung "use strict";weist den Browser an, den Strict-Modus zu verwenden, bei dem es sich um einen reduzierten und sichereren Funktionsumfang von JavaScript handelt.

Liste der Funktionen (nicht vollständig)

1. Verbietet globale Variablen. (Fängt fehlende varDeklarationen und Tippfehler in Variablennamen ab)

2. Stille fehlgeschlagene Zuweisungen führen zu Fehlern im strengen Modus (Zuweisung NaN = 5;)

3. Versuche, nicht löschbare Eigenschaften zu löschen, führen zu ( delete Object.prototype)

4. Erfordert, dass alle Eigenschaftsnamen in einem Objektliteral eindeutig sind ( var x = {x1: "1", x1: "2"})

5. Funktionsparameternamen müssen eindeutig sein ( function sum (x, x) {...})

6. Verbietet die oktale Syntax ( var x = 023;einige Entwickler gehen fälschlicherweise davon aus, dass eine vorhergehende Null nichts zur Änderung der Zahl beiträgt.)

7. Verbietet das withSchlüsselwort

8. eval Im strengen Modus werden keine neuen Variablen eingeführt

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

10. Verbietet das Binden oder Zuweisen der Namen evalund argumentsin jeglicher Form

11. Der strikte Modus vergleicht die Eigenschaften des argumentsObjekts nicht mit den formalen Parametern. (dh in function sum (a,b) { return arguments[0] + b;}Dies funktioniert, weil arguments[0]gebunden ist aund so weiter.)

12. arguments.callee wird nicht unterstützt

[Ref: Strenger Modus , Mozilla Developer Network ]

Wenn die Leute sich Sorgen um die Verwendung use strictmachen, lohnt es sich möglicherweise, diesen Artikel zu lesen:

ECMAScript 5 'Strenger Modus' Unterstützung in Browsern. Was bedeutet das?
NovoGeek.com - Krishnas Weblog

Es geht um Browserunterstützung, aber was noch wichtiger ist, wie man sicher damit umgeht:

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, alle hart aufgeladenen Programmierer: Das Anwenden "use strict"auf vorhandenen Code kann gefährlich sein! Bei diesem Ding handelt es sich nicht um einen Aufkleber zum Wohlfühlen und zum glücklichen Gesicht, auf den Sie den Code klopfen können, um ihn "besser" zu machen. Mit dem "use strict"Pragma wird der Browser plötzlich Ausnahmen an zufälligen Stellen auslösen, die er noch nie zuvor ausgelöst hat, nur weil Sie an dieser Stelle etwas tun, das standardmäßiges / loses JavaScript gerne zulässt, aber striktes JavaScript verabscheut! Möglicherweise haben Sie Verstöße gegen die Strenge, die sich in selten verwendeten Aufrufen in Ihrem Code verstecken und nur dann eine Ausnahme auslösen, wenn sie schließlich ausgeführt werden - beispielsweise in der Produktionsumgebung, die Ihre zahlenden Kunden verwenden!

Wenn Sie den Sprung "use strict"wagen wollen, ist es eine gute Idee, sich neben umfassenden Komponententests und einer streng konfigurierten JSHint-Build-Aufgabe zu bewerben , die Ihnen die Gewissheit gibt, dass es keine dunkle Ecke Ihres Moduls gibt, die nur wegen Ihnen schrecklich explodiert Ich habe den Strict Mode aktiviert. Oder, hey, hier ist eine andere Option: Fügen Sie einfach keinen "use strict"Ihrer Legacy-Codes hinzu, es ist wahrscheinlich sicherer, ehrlich. DEFINITIV KEINE"use strict" Module hinzufügen , die Sie nicht besitzen oder warten, wie z. B. Module von Drittanbietern.

Ich denke, obwohl es ein tödliches Tier im Käfig ist, "use strict"kann es gutes Zeug sein, aber man muss es richtig machen. Die beste Zeit, um streng zu werden, ist, wenn Ihr Projekt auf der grünen Wiese steht und Sie bei Null anfangen. Konfigurieren Sie JSHint/JSLintmit allen Warnungen und Optionen, die so eng wie möglich sind, ein gutes Build- / Test- / Assert-System, wie Sie es sich vorgenommen haben Grunt+Karma+Chai, und markieren Sie erst dann alle Ihre neuen Module als "use strict". Seien Sie bereit, viele kleine Fehler und Warnungen zu beheben. Stellen Sie sicher, dass jeder die Schwerkraft versteht, indem Sie den Build auf FAIL konfigurieren, wenn JSHint/JSLintVerstöße auftreten.

Mein Projekt war kein Greenfield-Projekt, als ich es adoptierte "use strict". Infolgedessen ist meine IDE voller roter Markierungen, da ich nicht die "use strict"Hälfte meiner Module habe, und JSHint beschwert sich darüber. Es erinnert mich daran, was ich in Zukunft tun sollte. Mein Ziel ist es, aufgrund all meiner fehlenden "use strict"Aussagen frei von roten Flecken zu sein , aber das ist jetzt Jahre entfernt.

Die Verwendung 'use strict';verbessert Ihren Code nicht plötzlich.

Der strikte JavaScript-Modus ist eine Funktion in ECMAScript 5 . Sie können den strengen Modus aktivieren, indem Sie dies oben in Ihrem Skript / Ihrer Funktion deklarieren.

'use strict';

Wenn eine JavaScript-Engine diese Anweisung sieht , beginnt sie, den Code in einem speziellen Modus zu interpretieren. In diesem Modus werden Fehler ausgelöst, wenn bestimmte Codierungspraktiken erkannt werden, die potenzielle Fehler darstellen können (was die Begründung für den strengen Modus ist).

Betrachten Sie dieses Beispiel:

var a = 365;
var b = 030;

In ihrer Besessenheit, die numerischen Literale auszurichten, hat der Entwickler die Variable versehentlich bmit einem oktalen Literal initialisiert . Im nicht strengen Modus wird dies als numerisches Literal mit Wert 24(in Basis 10) interpretiert . Der strikte Modus löst jedoch einen Fehler aus.

Eine nicht erschöpfende Liste von Spezialitäten im strengen Modus finden Sie in dieser Antwort .

Wo soll ich verwenden 'use strict';?

• In meiner neuen JavaScript-Anwendung: Absolut! Der strikte Modus kann als Whistleblower verwendet werden, wenn Sie etwas Dummes mit Ihrem Code tun.

• In meinem vorhandenen JavaScript-Code: Wahrscheinlich nicht! Wenn Ihr vorhandener JavaScript-Code Anweisungen enthält, die im strengen Modus verboten sind, wird die Anwendung einfach unterbrochen. Wenn Sie einen strengen Modus wünschen, sollten Sie bereit sein, Ihren vorhandenen Code zu debuggen und zu korrigieren. Aus diesem Grund verwenden 'use strict';nicht plötzlich Ihren Code besser machen .

Wie verwende ich den strengen Modus?

1. Fügen Sie eine 'use strict';Anweisung über Ihrem Skript ein:

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

   Beachten Sie, dass alles in der Datei myscript.jsim strengen Modus interpretiert wird.

2. Oder fügen Sie eine 'use strict';Anweisung über Ihren Funktionskörper ein:

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

   Alles im lexikalischen Funktionsumfang doSomethingwird im strengen Modus interpretiert. Das Wort lexikalischer Geltungsbereich ist hier wichtig. Wenn Ihr strenger Code beispielsweise eine Funktion einer Bibliothek aufruft, die nicht streng ist , wird nur Ihr Code im strengen Modus ausgeführt und nicht die aufgerufene Funktion. Siehe diese Antwort für eine bessere Erklärung.

Welche Dinge sind im strengen Modus verboten?

Ich habe einen schönen Artikel gefunden , der einige Dinge beschreibt, die im strengen Modus verboten sind (beachten Sie, dass dies keine exklusive Liste ist):

Umfang

In der Vergangenheit war JavaScript verwirrt darüber, wie Funktionen funktionieren. Manchmal scheinen sie statisch zu sein, aber bei einigen Funktionen verhalten sie sich so, als wären sie dynamisch. Dies ist verwirrend und erschwert das Lesen und Verstehen von Programmen. Missverständnisse verursachen Fehler. Es ist auch ein Problem für die Leistung. Das statische Scoping würde eine variable Bindung zur Kompilierungszeit ermöglichen, aber die Anforderung eines dynamischen Bereichs bedeutet, dass die Bindung auf die Laufzeit verschoben werden muss, was mit einem erheblichen Leistungsverlust verbunden ist.

Im strengen Modus muss die gesamte Variablenbindung statisch erfolgen. Das bedeutet, dass die Funktionen, für die zuvor eine dynamische Bindung erforderlich war, entfernt oder geändert werden müssen. Insbesondere wird die with-Anweisung eliminiert und die Fähigkeit der eval-Funktion, die Umgebung ihres Aufrufers zu manipulieren, ist stark eingeschränkt.

Einer der Vorteile von striktem Code besteht darin, dass Tools wie YUI Compressor bei der Verarbeitung bessere Arbeit leisten können.

Implizierte globale Variablen

JavaScript hat globale Variablen impliziert. Wenn Sie eine Variable nicht explizit deklarieren, wird implizit eine globale Variable für Sie deklariert. Dies erleichtert Anfängern das Programmieren, da sie einige ihrer grundlegenden Hausarbeiten vernachlässigen können. Dies erschwert jedoch die Verwaltung größerer Programme erheblich und beeinträchtigt die Zuverlässigkeit erheblich. Im strengen Modus werden implizite globale Variablen nicht mehr erstellt. Sie sollten alle Ihre Variablen explizit deklarieren.

Globale Leckage

Es gibt eine Reihe von Situationen, die dazu führen können this , dass Sie an das globale Objekt gebunden sind. Wenn Sie beispielsweise vergessen, newbeim Aufrufen einer Konstruktorfunktion das Präfix anzugeben, wird der Konstruktor thisunerwartet an das globale Objekt gebunden. Statt ein neues Objekt zu initialisieren, werden globale Variablen stillschweigend manipuliert. In diesen Situationen wird die Strict - Modus statt binden thisan undefined, die den Konstruktor verursacht eine Ausnahme statt zu werfen, so dass der Fehler viel früher erkannt werden.

Lauter Fehler

JavaScript hatte immer schreibgeschützte Eigenschaften, aber Sie konnten sie nicht selbst erstellen, bis die ES5- Object.createProperty Funktion diese Funktion verfügbar machte . Wenn Sie versuchen, einer schreibgeschützten Eigenschaft einen Wert zuzuweisen, schlägt dies unbemerkt fehl. Die Zuweisung würde den Wert der Eigenschaft nicht ändern, aber Ihr Programm würde so ablaufen, als ob es dies getan hätte. Dies ist ein Integritätsrisiko, das dazu führen kann, dass Programme in einen inkonsistenten Zustand versetzt werden. Im strengen Modus wird beim Versuch, eine schreibgeschützte Eigenschaft zu ändern, eine Ausnahme ausgelöst.

Oktal

Die oktale (oder Basis 8) Darstellung von Zahlen war äußerst nützlich, wenn Sie auf Maschinenebene auf Maschinen programmierten, deren Wortgröße ein Vielfaches von 3 war. Sie benötigten Oktal, wenn Sie mit dem CDC 6600-Mainframe arbeiteten, der eine Wortgröße von 60 Bit hatte. Wenn Sie Oktal lesen könnten, könnten Sie ein Wort als 20-stellig betrachten. Zwei Ziffern stellten den Operationscode dar, und eine Ziffer identifizierte eines von 8 Registern. Während des langsamen Übergangs von Maschinencodes zu Hochsprachen wurde es als nützlich erachtet, Oktalformen in Programmiersprachen bereitzustellen.

In C wurde eine äußerst unglückliche Darstellung der Oktalität gewählt: Führende Null. In C 0100bedeutet dies also 64, nicht 100 und 08ist ein Fehler, nicht 8. Leider wurde dieser Anachronismus in fast alle modernen Sprachen kopiert, einschließlich JavaScript, wo er nur zum Erstellen von Fehlern verwendet wird. Es hat keinen anderen Zweck. Im strengen Modus sind Oktalformen also nicht mehr zulässig.

Und so weiter

Das Argument-Pseudo-Array wird in ES5 etwas Array-ähnlicher. Im strengen Modus verliert es seine calleeund caller Eigenschaften. Dies ermöglicht es Ihnen arguments, Ihren nicht vertrauenswürdigen Code weiterzugeben , ohne viel vertraulichen Kontext aufzugeben. Auch die argumentsEigenschaft von Funktionen entfällt.

Im strengen Modus führen doppelte Schlüssel in einem Funktionsliteral zu einem Syntaxfehler. Eine Funktion kann nicht zwei Parameter mit demselben Namen haben. Eine Funktion kann keine Variable mit demselben Namen wie einer ihrer Parameter haben. Eine Funktion kann keine deleteeigenen Variablen haben. Ein Versuch zu deleteeiner nicht konfigurierbaren Eigenschaft löst jetzt eine Ausnahme aus. Primitive Werte werden nicht implizit umbrochen.

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

ECMAScript 5 fügt eine Liste reservierter Wörter hinzu. Wenn Sie sie als Variablen oder Argumente verwenden, gibt der strikte Modus einen Fehler aus. Die reservierten Wörter sind:

implements, interface, let, package, private, protected, public, static, Undyield

Weiterführende Literatur

• Strenger Modus - JavaScript | MDN
• Browserunterstützung für den strengen Modus
• Übergang in den strengen Modus

Ich empfehle jedem Entwickler dringend, jetzt den strengen Modus zu verwenden. Es gibt genügend Browser, die dies unterstützen, sodass der strikte Modus uns zu Recht vor Fehlern bewahrt, von denen wir nicht einmal wussten, dass sie in Ihrem Code enthalten sind.

Anscheinend wird es im Anfangsstadium Fehler geben, auf die wir noch nie zuvor gestoßen sind. Um den vollen Nutzen zu erzielen, müssen wir nach dem Wechsel in den strengen Modus ordnungsgemäße Tests durchführen, um sicherzustellen, dass wir alles erfasst haben. Auf jeden Fall werfen wir nicht einfach use strictunseren Code ein und gehen davon aus, dass es keine Fehler gibt. Die Abwanderung ist also, dass es Zeit ist, diese unglaublich nützliche Sprachfunktion zu verwenden, um besseren Code zu schreiben.

Zum Beispiel,

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

JSLint ist ein Debugger von Douglas Crockford. Fügen Sie einfach Ihr Skript ein und es wird schnell nach erkennbaren Problemen und Fehlern in Ihrem Code suchen.

Ich möchte eine etwas fundiertere Antwort anbieten, die die anderen Antworten ergänzt. Ich hatte gehofft, die beliebteste Antwort zu bearbeiten, bin aber gescheitert. Ich habe versucht, es so umfassend und vollständig wie möglich zu gestalten.

Weitere Informationen finden Sie in der MDN-Dokumentation .

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

Richtlinien ähneln Aussagen, unterscheiden sich jedoch.

• use strictenthält keine Schlüsselwörter: Die Direktive ist eine einfache Ausdrucksanweisung, die aus einem speziellen Zeichenfolgenliteral (in einfachen oder doppelten Anführungszeichen) besteht. JavaScript-Engines, die ECMAScript 5 nicht implementieren, sehen lediglich eine Ausdrucksanweisung ohne Nebenwirkungen. Es wird erwartet, dass zukünftige Versionen der ECMAScript-Standards useals echtes Schlüsselwort eingeführt werden. Die Zitate würden dadurch überholt.
• use strictkann nur am Anfang eines Skripts oder einer Funktion verwendet werden, dh es muss vor jeder anderen (realen) Anweisung stehen. Es muss nicht die erste Anweisung in einem Funktionsskript sein: Es können andere Anweisungsausdrücke vorangestellt werden, die aus Zeichenfolgenliteralen bestehen (und JavaScript-Implementierungen können sie als implementierungsspezifische Anweisungen behandeln). String-Literal-Anweisungen, die auf eine erste echte Anweisung (in einem Skript oder einer Funktion) folgen, sind einfache Ausdrucksanweisungen. Dolmetscher dürfen sie nicht als Richtlinien interpretieren und sie haben keine Wirkung.

Die use strictAnweisung gibt an, dass der folgende Code (in einem Skript oder einer Funktion) strenger Code ist. Der Code auf der höchsten Ebene eines Skripts (Code, der nicht in einer Funktion enthalten ist) wird als strenger Code betrachtet, wenn das Skript eine use strictDirektive enthält . Der Inhalt einer Funktion wird als strenger Code betrachtet, wenn die Funktion selbst in einem strengen Code definiert ist oder wenn die Funktion eine use strictDirektive enthält . Code, der an eine eval()Methode übergeben wird, gilt als strenger Code, wenn eval()er von einem strengen Code aufgerufen wurde oder die use strictDirektive selbst enthält .

Der strikte Modus von ECMAScript 5 ist eine eingeschränkte Teilmenge der JavaScript-Sprache, die relevante Sprachdefizite beseitigt und eine strengere Fehlerprüfung und höhere Sicherheit bietet. Im Folgenden werden die Unterschiede zwischen dem strengen Modus und dem normalen Modus aufgeführt (von denen die ersten drei besonders wichtig sind):

• Sie können die withAnweisung nicht im strengen Modus verwenden.
• Im strengen Modus müssen alle Variablen deklariert werden: Wenn Sie einem Bezeichner einen Wert zuweisen, der nicht als Variable, Funktion, Funktionsparameter, catch-Klausel-Parameter oder Eigenschaft des Global deklariert wurde Object, erhalten Sie einen ReferenceError. Im normalen Modus wird der Bezeichner implizit als globale Variable deklariert (als Eigenschaft der globalen Object).
• Im strengen Modus hat das Schlüsselwort thisden Wert undefinedin Funktionen, die als Funktionen (nicht als Methoden) aufgerufen wurden. (Im normalen Modus zeigt thisimmer auf die globale Object). Dieser Unterschied kann verwendet werden, um zu testen, ob eine Implementierung den strengen Modus unterstützt:

var hasStrictMode = (function() { "use strict"; return this===undefined }());

• Auch wenn eine Funktion mit call()oder applyim strengen Modus aufgerufen wird , thisist dies genau der Wert des ersten Arguments des Aufrufs call()oder apply(). (Im Normalmodus nullund undefinedwerden durch die globale ersetzt Objectund Werte, die nicht Objekte, sind gegossen in Objekte.)

• Im strengen Modus erhalten Sie ein TypeError, wenn Sie versuchen, schreibgeschützten Eigenschaften zuzuweisen oder neue Eigenschaften für ein nicht erweiterbares Objekt zu definieren. (Im normalen Modus schlagen beide einfach ohne Fehlermeldung fehl.)

• Im strengen Modus können Sie beim Übergeben von Code eval()keine Variablen oder Funktionen im Bereich des Aufrufers deklarieren oder definieren (wie im normalen Modus). Stattdessen wird ein neuer Bereich für erstellt eval()und die Variablen und Funktionen befinden sich in diesem Bereich. Dieser Bereich wird nach eval()Abschluss der Ausführung zerstört.
• Im strengen Modus enthält das Argument-Objekt einer Funktion eine statische Kopie der Werte, die an diese Funktion übergeben werden. Im normalen Modus hat das Argument-Objekt ein etwas "magisches" Verhalten: Die Elemente des Arrays und die genannten Funktionsparameter verweisen beide auf denselben Wert.
• Im strengen Modus erhalten Sie eine, SyntaxErrorwenn dem deleteOperator eine nicht qualifizierte Kennung (eine Variable, eine Funktion oder ein Funktionsparameter) folgt. Im normalen Modus würde der deleteAusdruck nichts tun und wird ausgewertet false.
• Im strengen Modus erhalten Sie eine, TypeErrorwenn Sie versuchen, eine nicht konfigurierbare Eigenschaft zu löschen. (Im normalen Modus schlägt der Versuch einfach fehl und der deleteAusdruck wird ausgewertet false).
• Im strengen Modus wird dies als syntaktischer Fehler angesehen, wenn Sie versuchen, mehrere Eigenschaften mit demselben Namen für ein Objektliteral zu definieren. (Im normalen Modus gibt es keinen Fehler.)
• Im strengen Modus wird dies als syntaktischer Fehler angesehen, wenn eine Funktionsdeklaration mehrere Parameter mit demselben Namen enthält. (Im normalen Modus gibt es keinen Fehler.)
• Im strengen Modus sind oktale Literale nicht zulässig (dies sind Literale, die mit beginnen 0x. (Im normalen Modus erlauben einige Implementierungen oktale Literale.)
• Im strengen Modus werden die Bezeichner evalund argumentswie Schlüsselwörter behandelt. Sie können ihren Wert nicht ändern, ihnen keinen Wert zuweisen und sie nicht als Namen für Variablen, Funktionen, Funktionsparameter oder Bezeichner eines catch-Blocks verwenden.
• Im strengen Modus gibt es weitere Einschränkungen für die Möglichkeiten, den Aufrufstapel zu untersuchen. arguments.callerund arguments.calleeverursachen eine TypeErrorin einer Funktion im strengen Modus. Darüber hinaus verursachen einige Aufrufer- und Argumenteigenschaften von Funktionen im strengen Modus ein, TypeErrorwenn Sie versuchen, sie zu lesen.

Meine zwei Cent:

Eines der Ziele des strengen Modus ist es, ein schnelleres Debuggen von Problemen zu ermöglichen. Es hilft den Entwicklern, indem es Ausnahmen auslöst, wenn bestimmte falsche Dinge auftreten, die zu einem stillen und seltsamen Verhalten Ihrer Webseite führen können. In dem Moment, in dem wir use strictden Code verwenden, werden Fehler ausgegeben, die dem Entwickler helfen, ihn im Voraus zu beheben.

Einige wichtige Dinge, die ich nach der Verwendung gelernt habe use strict:

Verhindert die Deklaration globaler Variablen:

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

Dieser Code wird nun nameoftreeim globalen Bereich erstellt, auf den mit zugegriffen werden kann window.nameoftree. Wenn wir use strictden Code implementieren , würde dies einen Fehler auslösen.

Nicht erfasster Referenzfehler: nameoftree ist nicht definiert

Sample

Beseitigt withAussage:

withAnweisungen können nicht mit Tools wie uglify-js minimiert werden . Sie sind auch veraltet und werden aus zukünftigen JavaScript-Versionen entfernt.

Sample

Verhindert Duplikate:

Wenn wir eine doppelte Eigenschaft haben, wird eine Ausnahme ausgelöst

Nicht erfasster SyntaxError: Doppelte Dateneigenschaft im Objektliteral im strengen Modus nicht zulässig

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

Es gibt nur wenige mehr, aber ich muss mehr darüber lernen.

Wenn Sie einen Browser verwenden, der im letzten Jahr oder so veröffentlicht wurde, unterstützt er höchstwahrscheinlich den JavaScript Strict-Modus. Nur ältere Browser, bevor ECMAScript 5 zum aktuellen Standard wurde, unterstützen dies nicht.

Die Anführungszeichen um den Befehl stellen sicher, dass der Code auch in älteren Browsern funktioniert (obwohl die Dinge, die im strengen Modus einen Syntaxfehler erzeugen, im Allgemeinen nur dazu führen, dass das Skript in diesen älteren Browsern auf eine schwer zu erkennende Weise fehlerhaft funktioniert).

Beim Hinzufügen "use strict";wird in den folgenden Fällen ein SyntaxError ausgelöst, bevor das Skript ausgeführt wird:

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

• Funktion in Blöcken deklarieren

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

• Oktale Syntax

  var n = 023;

• this Zeigen Sie auf das globale Objekt.

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

• Deklarieren des doppelten Namens für einen Eigenschaftsnamen in einem Objektliteral

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

  Dies ist in ECMAScript 6 ( Fehler 1041128 ) nicht mehr der Fall .

• Deklarieren von zwei Funktionsargumenten mit derselben Namensfunktion

  f(a, b, b){}

• Festlegen eines Werts für eine nicht deklarierte Variable

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

• Verwenden deleteeines Variablennamensdelete myVariable;

• Verwenden von evaloder argumentsals Variablen- oder Funktionsargumentname

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

Quellen:

• Übergang in den strengen Modus auf MDN

• Strenger Modus auf MDN

• Der strenge JavaScript-Modus und warum Sie ihn in Colin J. Ihrigs Blog verwenden sollten (archivierte Version)

Im strengen Modus werden verschiedene Änderungen an der normalen JavaScript-Semantik vorgenommen:

• Beseitigt einige stille JavaScript-Fehler, indem sie geändert werden, um Fehler auszulösen.

• behebt Fehler, die es JavaScript-Engines erschweren, Optimierungen durchzuführen.

• verbietet eine Syntax, die wahrscheinlich in zukünftigen Versionen von ECMAScript definiert wird.

Weitere Informationen finden Sie unter Strict Mode-Javascript

"Verwenden Sie streng"; ist eine Versicherung, dass Programmierer die losen oder schlechten Eigenschaften von JavaScript nicht nutzen. Es ist eine Anleitung, genau wie ein Lineal Ihnen hilft, gerade Linien zu ziehen. "Use Strict" hilft Ihnen beim "Straight Coding".

Diejenigen, die es vorziehen, keine Lineale zu verwenden, um ihre Zeilen gerade zu machen, landen normalerweise auf diesen Seiten und fordern andere auf, ihren Code zu debuggen.

Glaube mir. Der Overhead ist im Vergleich zu schlecht entworfenem Code vernachlässigbar. Doug Crockford, der seit mehreren Jahren ein leitender JavaScript-Entwickler ist, hat hier einen sehr interessanten Beitrag . Persönlich kehre ich gerne die ganze Zeit zu seiner Website zurück, um sicherzustellen, dass ich meine gute Praxis nicht vergesse.

Die moderne JavaScript-Praxis sollte immer den "Use Strict" hervorrufen. Pragma. Der einzige Grund, warum die ECMA-Gruppe den "Strict" -Modus optional gemacht hat, besteht darin, weniger erfahrenen Codierern den Zugriff auf JavaScript zu ermöglichen und dann Zeit zu geben, sich an die neuen und sichereren Codierungspraktiken anzupassen.

Wenn use strictSie ab diesem Punkt alle vertraulichen JavaScript-Dateien in den Anfang aufnehmen, können Sie ein kleinerer JavaScript-Programmierer sein und vermeiden, dass Zufallsvariablen global werden und sich die Dinge stillschweigend ändern.

Zitat aus w3schools :

Die "strenge Verwendung" -Richtlinie

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

Es ist keine Anweisung, sondern ein wörtlicher Ausdruck, der von früheren Versionen von JavaScript ignoriert wird.

Der Zweck von "use strict" besteht darin, anzugeben, dass der Code im "strict mode" ausgeführt werden soll.

Im strengen Modus können Sie beispielsweise keine nicht deklarierten Variablen verwenden.

Warum strenger Modus?

Der strikte Modus erleichtert das Schreiben von "sicherem" JavaScript.

Der strikte Modus ändert die zuvor akzeptierte "schlechte Syntax" in echte Fehler.

Wenn Sie beispielsweise in normalem JavaScript einen Variablennamen falsch eingeben, wird eine neue globale Variable erstellt. Im strengen Modus wird dadurch ein Fehler ausgegeben, der es unmöglich macht, versehentlich eine globale Variable zu erstellen.

In normalem JavaScript erhält ein Entwickler keine Fehlerrückmeldung, wenn nicht beschreibbaren Eigenschaften Werte zugewiesen werden.

Im strengen Modus löst jede Zuweisung zu einer nicht beschreibbaren Eigenschaft, einer Nur-Getter-Eigenschaft, einer nicht vorhandenen Eigenschaft, einer nicht vorhandenen Variablen oder einem nicht vorhandenen Objekt einen Fehler aus.

Weitere Informationen finden Sie unter http://www.w3schools.com/js/js_strict.asp

"use strict"Lässt JavaScript-Code im strengen Modus laufen , was im Grunde bedeutet, dass vor der Verwendung alles definiert werden muss. Der Hauptgrund für die Verwendung des strengen Modus besteht darin, die versehentliche globale Verwendung undefinierter Methoden zu vermeiden.

Auch im strengen Modus laufen die Dinge schneller, einige Warnungen oder stille Warnungen werfen schwerwiegende Fehler auf. Es ist besser, sie immer zu verwenden, um einen saubereren Code zu erstellen.

"use strict"wird häufig für die Verwendung in ECMA5 benötigt. In ECMA6 ist es standardmäßig Teil von JavaScript , sodass es nicht hinzugefügt werden muss, wenn Sie ES6 verwenden.

Schauen Sie sich diese Aussagen und Beispiele aus MDN an:

Die Direktive
"use strict" Die Direktive "use strict" ist neu in JavaScript 1.8.5 (ECMAScript Version 5). Es ist keine Anweisung, sondern ein wörtlicher Ausdruck, der von früheren Versionen von JavaScript ignoriert wird. Der Zweck von "use strict" besteht darin, anzugeben, dass der Code im "strict mode" ausgeführt werden soll. Im strengen Modus können Sie beispielsweise keine nicht deklarierten Variablen verwenden.

Beispiele für die Verwendung von "use strict":
Strenger Modus für Funktionen: Um den strengen Modus für eine Funktion aufzurufen, geben Sie die genaue Anweisung "use strict" ein. (oder 'use strict';) im Hauptteil der Funktion vor allen anderen Anweisungen.

1) strenger Modus in 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) Strict-Modus für das gesamte Skript

'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 mehr über MDN lesen .

Einige Mitglieder des ECMAScript-Ausschusses sprechen gut darüber: Änderungen an JavaScript, Teil 1: ECMAScript 5 " darüber, wie die schrittweise Verwendung des "use strict"Schalters es JavaScript-Implementierern ermöglicht, viele der gefährlichen Funktionen von JavaScript zu bereinigen, ohne plötzlich jede Website zu beschädigen in der Welt.

Natürlich geht es auch darum, was viele dieser Fehlfunktionen sind (waren) und wie ECMAScript 5 sie behebt.

Kleine Beispiele zum Vergleichen:

Nicht strenger Modus:

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

Strikter Modus:

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

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

Nicht strenger 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 dies use strictin EcmaScript 5 eingeführt wurde und seitdem beibehalten wurde.

Nachfolgend sind die Bedingungen aufgeführt, um den strengen Modus in ES6 und ES7 auszulösen :

• Globaler Code ist ein Code im strengen Modus, wenn er mit einem Direktivenprolog beginnt, der eine Richtlinie zur strikten Verwendung enthält (siehe 14.1.1).
• Der Modulcode ist immer ein strikter Moduscode.
• Alle Teile einer ClassDeclaration oder einer ClassExpression sind strikte Moduscodes .
• Eval-Code ist ein Code für den strengen Modus, wenn er mit einem Richtlinienprolog beginnt, der eine Richtlinie zur strikten Verwendung enthält, oder wenn der Aufruf von eval eine direkte Bewertung (siehe 12.3.4.1) ist, die im Code für den strengen Modus enthalten ist.
• Funktionscode ist ein strikter Moduscode, wenn die zugehörige FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition oder ArrowFunction im strengen Moduscode enthalten ist oder wenn der Code, der den Wert des internen Slots der Funktion [[ECMAScriptCode]] erzeugt, mit einem Direktivenprolog beginnt das enthält eine Use Strict Directive.
• Funktionscode, der als Argumente für die integrierten Funktions- und Generatorkonstruktoren bereitgestellt wird, ist ein Code für den strengen Modus, wenn das letzte Argument ein String ist, der bei der Verarbeitung ein FunctionBody ist , der mit einem Direktivenprolog beginnt, der eine Use Strict-Direktive enthält.

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

1. Verhindert die versehentliche Deklaration globaler Variablen. Durch die Verwendung "use strict()"wird sichergestellt, dass Variablen varvor der Verwendung mit deklariert werden. Z.B:

   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: Die "use strict"Direktive wird nur am Anfang eines Skripts oder einer Funktion erkannt.

3. Die Zeichenfolge "arguments"kann nicht als Variable verwendet werden:

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

4. Beschränkt die Verwendung von Schlüsselwörtern als Variablen. Der Versuch, sie zu verwenden, führt zu Fehlern.

Kurz gesagt, Ihr Code wird weniger fehleranfällig und Sie schreiben guten Code.

Um mehr darüber zu lesen, können Sie hier verweisen .

"benutze streng"; ist die ECMA-Anstrengung, JavaScript ein bisschen robuster zu machen. Es bringt JS in den Versuch, es zumindest ein wenig "streng" zu machen (andere Sprachen implementieren seit den 90er Jahren strenge Regeln). Es "zwingt" JavaScript-Entwickler tatsächlich, eine Art von Best Practices für die Codierung zu befolgen. Trotzdem ist JavaScript sehr zerbrechlich. Es gibt keine typisierten Variablen, typisierten Methoden usw. Ich empfehle JavaScript-Entwicklern dringend, eine robustere Sprache wie Java oder ActionScript3 zu lernen und dieselben Best Practices in Ihren JavaScript-Code zu implementieren. Dies funktioniert besser und ist einfacher debuggen.

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

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

Wenn Sie "use strict";ganz oben in Ihre JS-Datei schreiben, wird die strenge Syntaxprüfung aktiviert. Es erledigt folgende Aufgaben für uns:

1. Zeigt einen Fehler an, wenn Sie versuchen, einer nicht deklarierten Variablen zuzuweisen

2. verhindert, dass Sie wichtige JS-Systembibliotheken überschreiben

3. verbietet einige unsichere oder fehleranfällige Sprachfunktionen

use strictfunktioniert auch innerhalb einzelner Funktionen. Es ist immer eine bessere Praxis, use strictin Ihren Code aufzunehmen.

Browserkompatibilitätsproblem: Die "use" -Anweisungen sollen abwärtskompatibel sein. Browser, die sie nicht unterstützen, sehen nur ein Zeichenfolgenliteral, auf das nicht weiter verwiesen wird. Also werden sie darüber hinweggehen und weitermachen.

use strictDies ist eine Möglichkeit, Ihren Code sicherer zu machen, da Sie keine gefährlichen Funktionen verwenden können, die möglicherweise nicht wie erwartet funktionieren. Und wie bereits geschrieben, wird der Code dadurch strenger.

Use Strict wird verwendet, um häufige und wiederholte Fehler anzuzeigen, sodass sie unterschiedlich behandelt werden, und ändert die Art und Weise, wie Java-Skripte ausgeführt werden.

• Verhindert versehentliche Globale

• Keine Duplikate

• Eliminiert mit

• Beseitigt diesen Zwang

• Sicherere Bewertung ()

• Fehler für unveränderliche

Sie können diesen Artikel auch für Details lesen

Normalerweise folgt JavaScript keinen strengen Regeln, wodurch sich die Fehlerwahrscheinlichkeit erhöht. Nach der Verwendung "use strict"sollte der JavaScript-Code strengen Regeln wie in anderen Programmiersprachen folgen, z. B. Verwendung von Terminatoren, Deklaration vor der Initialisierung usw.

Wenn "use strict"der Code verwendet wird, sollte er nach strengen Regeln geschrieben werden, um die Wahrscheinlichkeit von Fehlern und Mehrdeutigkeiten zu verringern.

"benutze streng"; Definiert, dass JavaScript-Code im "strengen Modus" ausgeführt werden soll.

• Die Direktive "use strict" war neu in ECMAScript Version 5.
• Es ist keine Anweisung, sondern ein wörtlicher Ausdruck, der von früheren Versionen von JavaScript ignoriert wird.
• Der Zweck von "use strict" besteht darin, anzugeben, dass der Code im "strict mode" ausgeführt werden soll.
• Im strengen Modus können Sie beispielsweise keine nicht deklarierten Variablen verwenden.

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

Nachteil

Wenn ein Entwickler eine Bibliothek verwendet, die sich im strengen Modus befindet, der Entwickler jedoch daran gewöhnt ist, im normalen Modus zu arbeiten, ruft er möglicherweise einige Aktionen für die Bibliothek auf, die nicht wie erwartet funktionieren.

Schlimmer noch, da sich der Entwickler im normalen Modus befindet, hat er nicht die Vorteile, dass zusätzliche Fehler ausgelöst werden, sodass der Fehler möglicherweise unbemerkt fehlschlägt.

Wie oben aufgeführt, hindert Sie der strikte Modus daran, bestimmte Dinge zu tun.

Die Leute denken im Allgemeinen, dass Sie diese Dinge überhaupt nicht verwenden sollten, aber einige Entwickler mögen die Einschränkung nicht und möchten alle Funktionen der Sprache verwenden.

• Als grundlegendes Beispiel und als Referenz gehen Sie durch:

  https://www.tutorialsteacher.com/javascript/javascript-strict

Der strikte Modus kann Speicherlecks verhindern.

Bitte überprüfen Sie die unten stehende Funktion im nicht strengen 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, die nameinnerhalb der Funktion aufgerufen wird. Intern prüft der Compiler zunächst, ob in diesem Funktionsbereich eine Variable mit diesem bestimmten Namen deklariert ist. Da der Compiler verstanden hat, dass es keine solche Variable gibt, prüft er den äußeren Bereich. In unserem Fall ist es der globale Geltungsbereich. Wieder hat der Compiler verstanden, dass im globalen Raum auch keine Variable mit diesem Namen deklariert ist, und erstellt daher eine solche Variable für uns im globalen Raum. Konzeptionell wird diese Variable im globalen Bereich erstellt und ist in der gesamten Anwendung verfügbar.

Ein anderes Szenario ist, dass die Variable beispielsweise in einer untergeordneten Funktion deklariert wird. In diesem Fall überprüft der Compiler die Gültigkeit dieser Variablen im äußeren Bereich, dh der übergeordneten Funktion. Erst dann checkt es den globalen Raum ein und erstellt dort eine Variable für uns. Das bedeutet, dass zusätzliche Überprüfungen durchgeführt werden müssen. Dies wirkt sich auf die Leistung der Anwendung aus.

Schreiben wir nun die gleiche Funktion im strengen Modus.

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

Wir werden den folgenden Fehler erhalten.

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

Hier löst der Compiler den Referenzfehler aus. Im strengen Modus erlaubt uns der Compiler nicht, die Variable zu verwenden, ohne sie zu deklarieren. So können Speicherlecks verhindert werden. Darüber hinaus können wir optimierten Code schreiben.