it-swarm.com.de

Was macht "use strict" in JavaScript und was ist der Grund dafür?

Vor kurzem habe ich etwas von meinem JavaScript-Code durch Crockfords JSLint ausgeführt, und es gab den folgenden Fehler:

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

Bei der Suche wurde mir klar, dass einige Leute "use strict"; in ihren JavaScript-Code einfügen. Nachdem ich die Anweisung hinzugefügt hatte, wurde der Fehler nicht mehr angezeigt. Leider hat Google nicht viel von der Geschichte hinter dieser Zeichenfolge-Erklärung preisgegeben. Sicher muss es etwas damit zu tun haben, wie das JavaScript vom Browser interpretiert wird, aber ich habe keine Ahnung, wie der Effekt aussehen würde.

Worum geht es also bei "use strict";, was bedeutet das und ist es noch relevant?

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

7004
Mark Rogers

Dieser Artikel über den JavaScript Strict Mode 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 einem "strengen" Betriebskontext platzieren können. Dieser strikte Kontext verhindert, dass bestimmte Aktionen ausgeführt werden, und wirft weitere Ausnahmen auf.

Und:

Der strikte Modus hilft auf verschiedene Weise:

  • Es fängt einige gängige Programmierfehler auf und wirft Ausnahmen.
  • Sie verhindert oder wirft 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 "strikten Modus" auf die gesamte Datei anwenden können. Oder Sie können ihn nur für eine bestimmte Funktion verwenden (weiterhin Zitate aus John Resigs Artikel):

// Non-strict code...

(function(){
  "use strict";

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

// Non-strict code... 

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

Ich denke, es ist ein bisschen wie der "use strict", den Sie in Perl (daher der Name?) Verwenden können: Es hilft Ihnen, weniger Fehler zu machen, indem Sie mehr Dinge entdecken, die zu Brüchen führen könnten.

Derzeit ist es wird von allen gängigen Browsern unterstützt(Takt IE 9 und darunter).

4608
Pascal MARTIN

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

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

"use strict";

Wenn Sie es jetzt in Ihren Code einfügen, sollte dies bei aktuellen Browsern keine Probleme verursachen, da es nur eine Zeichenfolge ist. Es kann in Zukunft zu Problemen mit Ihrem Code führen, wenn Ihr Code gegen das Pragma verstößt. Wenn Sie beispielsweise foo = "bar" haben, ohne zuerst foo zu definieren, wird Ihr Code ausfallen ... was meiner Meinung nach gut ist.

1157
seth

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

Liste der Funktionen (nicht erschöpfend)

  1. Verbietet globale Variablen. (Fänge fehlen var-Deklarationen und Tippfehler in Variablennamen) 

  2. Stille, fehlerhafte Zuweisungen werden im strikten Modus fehlerhaft ausgegeben (Zuweisung von NaN = 5;). 

  3. Versuche, nicht wiederherstellbare Eigenschaften zu löschen, werden ausgelöst (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 devs gehen fälschlicherweise davon aus, dass eine vorangestellte Null die Zahl nicht ändert.) 

  7. Verbietet das Schlüsselwort with 

  8. eval führt im strikten Modus keine neuen Variablen ein 

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

  10. Verbietet die Bindung oder Zuordnung der Namen eval und arguments in jeglicher Form 

  11. Im strikten Modus werden die Eigenschaften des arguments-Objekts mit den Formalparametern nicht als Alias ​​bezeichnet. (d. h. in function sum (a,b) { return arguments[0] + b;} Dies funktioniert, weil arguments[0] an a und so weiter gebunden ist.)

  12. arguments.callee wird nicht unterstützt

[Ref: Strikter Modus , Mozilla Developer Network]

575
gprasant

Wenn Sie sich Sorgen machen, use strict zu verwenden, lohnt es sich vielleicht, diesen Artikel zu lesen: 

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

Es geht um Browser-Unterstützung, aber vor allem, 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.
*/
386
Jamie Hutber

Ein Wort der Vorsicht, Sie hart programmierten Programmierer: Die Anwendung von "use strict" auf vorhandenen Code kann gefährlich sein! Bei diesem Ding handelt es sich nicht um einen guten, fröhlichen Aufkleber, den Sie auf den Code setzen können, um ihn "besser" zu machen. Mit dem "use strict"-Pragma wirft der Browser plötzlich Ausnahmen an zufälligen Orten, die er noch nie geworfen hat, nur weil Sie an dieser Stelle etwas tun, das standardmäßiges/lockeres JavaScript glücklich erlaubt, aber strikte JavaScript-Abgriffe! Es kann sein, dass Verstöße gegen die Strenge in selten genutzten Anrufen in Ihrem Code verdeckt werden, die 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 wagen, ist es eine gute Idee, "use strict" zusammen mit umfangreichen Komponententests und einer streng konfigurierten JSHint-Buildaufgabe anzuwenden, die Ihnen ein gewisses Vertrauen geben wird, dass es keine dunklen Ecken Ihres Moduls gibt, die schrecklich explodieren Sie haben den Striktmodus aktiviert. Oder, hey, hier ist eine weitere Option: Fügen Sie einfach keinen "use strict" zu Ihrem alten Code hinzu. Wahrscheinlich ist es auf diese Weise sicherer. ENDLICH NICHT füge "use strict" zu Modulen hinzu, die du nicht besitzt oder pflegst, wie Module von Drittanbietern.

Ich denke, obwohl es ein tödlich eingesperrtes Tier ist, kann "use strict" gutes Zeug sein, aber man muss es richtig machen. Die beste Zeit, um streng zu gehen, ist, wenn Ihr Projekt auf der grünen Wiese ist und Sie bei Null anfangen. Konfigurieren Sie JSHint/JSLint mit allen Warnungen und Optionen, die so eng sind, wie es Ihrem Team möglich ist, ein gutes Build/Test/Assert-System wie Grunt+Karma+Chai, und erst dann beginnen alle Ihre neuen Module als "use strict" zu markieren. Seien Sie darauf vorbereitet, viele kleine Fehler und Warnungen zu heilen. Stellen Sie sicher, dass alle die Schwerkraft verstehen, indem Sie den Build auf FAIL konfigurieren, wenn JSHint/JSLint Verstöße verursacht.

Mein Projekt war kein Greenfield-Projekt, als ich "use strict" übernahm. Daher ist meine IDE voll mit roten Markierungen, da ich "use strict" nicht für die Hälfte meiner Module habe. JSHint beschwert sich darüber. Es ist eine Erinnerung an mich, was ich in Zukunft tun sollte. Mein Ziel ist es, wegen aller fehlenden "use strict"-Anweisungen rote Markierungen zu erhalten, aber das ist jetzt schon Jahre weg.

194
DWoldrich

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

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

'use strict';

Wenn eine JavaScript-Engine diese Direktive sieht, beginnt sie, den Code in einem speziellen Modus zu interpretieren. In diesem Modus werden Fehler ausgegeben, wenn bestimmte Codierungsverfahren erkannt werden, die potenzielle Fehler darstellen können (was die Gründe für den strengen Modus sind).

Betrachten Sie dieses Beispiel:

var a = 365;
var b = 030;

In ihrer Obsession, die numerischen Literale auszurichten, hat der Entwickler die Variable b versehentlich mit einem oktalen Literal initialisiert. Im nicht strengen Modus wird dies als numerisches Literal mit dem Wert 24 (In Basis 10) interpretiert. Im strikten Modus wird jedoch ein Fehler ausgegeben.

Eine nicht vollständige Liste der Spezialitäten im strengen Modus finden Sie unter diese Antwort .


Wo soll ich 'use strict'; Verwenden?

  • In meiner neu JavaScript-Anwendung: Auf jeden Fall! Der Strict-Modus kann als Hinweisgeber verwendet werden, wenn Sie etwas Dummes tun dein Code.

  • In meinem existierenden JavaScript-Code: Wahrscheinlich nicht! Wenn Ihr existierender JavaScript-Code Anweisungen enthält, die im Strict-Modus verboten sind wird die Anwendung einfach unterbrochen. Wenn Sie einen strikten Modus wünschen, sollten Sie bereit sein, den vorhandenen Code zu debuggen und zu korrigieren. Dies ist der Grund, warum mit 'use strict'; Ihr Code nicht plötzlich besser wird.


Wie verwende ich den strikten Modus?

  1. Fügen Sie eine 'use strict'; - Anweisung oben in Ihr Skript ein:

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

    Beachten Sie, dass alles in der Datei myscript.js Im strikten Modus interpretiert wird.

  2. Oder fügen Sie eine 'use strict'; - Anweisung oben auf Ihrem Funktionskörper ein:

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

    Alles, was im lexikalischen Bereich der Funktion doSomething steht, wird streng interpretiert. Das Wort lexikalischer Geltungsbereich ist hier wichtig. Siehe diese Antwort für eine bessere Erklärung.


Welche Dinge sind im strengen Modus verboten?

Ich habe einen Netter Artikel gefunden, der einige Dinge beschreibt, die im strengen Modus verboten sind (beachte, dass dies keine exklusive Liste ist):

Umfang

In der Vergangenheit war JavaScript in Bezug auf den Funktionsumfang verwirrt. Manchmal scheinen sie einen statischen Bereich zu haben, aber bei einigen Features 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. Statisches Scoping würde eine variable Bindung zum Zeitpunkt der Kompilierung 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 entfernt und die Fähigkeit der eval-Funktion, die Umgebung ihres Aufrufers zu manipulieren, wird stark eingeschränkt.

Einer der Vorteile von striktem Code ist, 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 Haushaltsaufgaben vernachlässigen können. Dies erschwert jedoch die Verwaltung größerer Programme und beeinträchtigt die Zuverlässigkeit erheblich. Im strikten Modus werden implizite globale Variablen nicht mehr erstellt. Sie sollten alle Ihre Variablen explizit deklarieren.

Weltweite Leckage

Es gibt eine Reihe von Situationen, die dazu führen können, dass this an das globale Objekt gebunden wird. Wenn Sie beispielsweise vergessen, beim Aufrufen einer Konstruktorfunktion das Präfix new anzugeben, wird das this des Konstruktors unerwartet an das globale Objekt gebunden. Statt also ein neues Objekt zu initialisieren, wird es stattdessen gebunden Manipulieren Sie im Stillen globale Variablen. In diesen Situationen bindet der strikte Modus stattdessen this an undefined, wodurch der Konstruktor stattdessen eine Ausnahme auslöst und der Fehler viel früher erkannt wird.

Lautes Versagen

JavaScript hatte immer schreibgeschützte Eigenschaften, aber Sie konnten sie nicht selbst erstellen, bis die ES5-Funktion Object.createProperty 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 eine Integritätsgefahr, die 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 Maschinen programmieren, deren Wortgröße ein Vielfaches von 3 betrug. Sie benötigten oktale Werte, wenn Sie mit dem CDC 6600-Mainframe mit einer Wortgröße von 60 Bit arbeiteten. Wenn Sie Oktal lesen könnten, könnten Sie ein Wort mit 20 Ziffern betrachten. Zwei Ziffern stellten den Operationscode dar, und eine Ziffer identifizierte eines von 8 Registern. Während des langsamen Übergangs von Maschinencodes zu höheren Sprachen wurde es als nützlich erachtet, oktale Formen in Programmiersprachen bereitzustellen.

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

Und so weiter

Das Argument Pseudo-Array wird in ES5 ein bisschen mehr Array-ähnlich. Im strikten Modus verliert es die Eigenschaften callee und caller. Dadurch ist es möglich, Ihren arguments an nicht vertrauenswürdigen Code zu übergeben, ohne viel vertraulichen Kontext aufzugeben. Außerdem wird die Eigenschaft arguments von Funktionen entfernt.

Im strikten Modus führen doppelte Tasten in einem Funktionsliteral zu einem Syntaxfehler. Eine Funktion kann nicht zwei gleichnamige Parameter haben. Eine Funktion kann keine Variable mit demselben Namen wie einer ihrer Parameter haben. Eine Funktion kann keine eigenen Variablen delete Ein Versuch, eine nicht konfigurierbare Eigenschaft zu delete, 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, wird im strikten Modus ein Fehler ausgegeben. Die reservierten Wörter sind:

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


Weitere Lektüre

152
sampathsris

Ich empfehle jedem Entwickler dringend, jetzt den strikten Modus zu verwenden. Es gibt genug Browser, die den strengen Modus unterstützen, um uns vor Fehlern zu schützen, von denen wir nicht einmal wussten, dass sie in Ihrem Code waren.

Anscheinend wird es im Anfangsstadium Fehler geben, die wir noch nie zuvor gesehen haben. Um den vollen Nutzen zu erzielen, müssen wir nach dem Umschalten in den strikten Modus ordnungsgemäße Tests durchführen, um sicherzustellen, dass wir alles erfasst haben. Wir werfen definitiv nicht nur use strict in unseren Code und gehen davon aus, dass es keine Fehler gibt. Die Abwanderung ist also, dass es an der 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 von Douglas Crockford geschriebener Debugger. Fügen Sie einfach Ihr Skript ein und es wird schnell nach auffälligen Problemen und Fehlern in Ihrem Code durchsucht.

128
Pank

Ich möchte eine etwas fundiertere Antwort anbieten, die die anderen Antworten ergänzt. Ich hatte gehofft, die beliebteste Antwort zu bearbeiten, aber es gelang mir nicht. 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 Direktive.

Anweisungen ähneln Anweisungen, unterscheiden sich jedoch.

  • use strict Enthä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 von ECMAScript-Standards use als echtes Schlüsselwort einführen. die Anführungszeichen würden dadurch hinfällig werden.
  • use strict Kann nur am Anfang eines Skripts oder einer Funktion verwendet werden, d. H. Es muss vor jeder anderen (reellen) Anweisung stehen. Es muss nicht die erste Anweisung in einem Funktionsskript sein. Vor dieser Anweisung können andere Anweisungsausdrücke stehen, die aus Zeichenfolgenliteralen bestehen (und JavaScript-Implementierungen können sie als implementierungsspezifische Anweisungen behandeln). String-Literale-Anweisungen, die auf eine erste echte Anweisung (in einem Skript oder einer Funktion) folgen, sind einfache Ausdrucksanweisungen. Dolmetscher dürfen sie nicht als Weisungen auslegen und haben keine Wirkung.

Die Direktive use strict Gibt an, dass der folgende Code (in einem Skript oder einer Funktion) strikter Code ist. Der Code auf der höchsten Ebene eines Skripts (Code, der sich nicht in einer Funktion befindet) wird als strikter Code betrachtet, wenn das Skript eine Direktive use strict 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 Direktive use strict Enthält. Code, der an eine eval() -Methode übergeben wird, wird als strenger Code betrachtet, wenn eval() aus einem strengen Code aufgerufen wurde oder die Direktive use strict 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 Anweisung with- nicht im strikten Modus verwenden.
  • Im strikten 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 globalen Object deklariert wurde, werden Sie dies tun Erhalte ein ReferenceError. Im normalen Modus wird der Bezeichner implizit als globale Variable deklariert (als Eigenschaft des globalen Object)
  • Im strikten Modus hat das Schlüsselwort this in Funktionen, die als Funktionen (nicht als Methoden) aufgerufen wurden, den Wert undefined. (Im normalen Modus zeigt this immer auf das globale Object). Dieser Unterschied kann verwendet werden, um zu testen, ob eine Implementierung den strikten Modus unterstützt:
var hasStrictMode = (function() { "use strict"; return this===undefined }());
  • Auch wenn eine Funktion mit call() oder apply im strikten Modus aufgerufen wird, ist this genau der Wert des ersten Arguments der call() oder apply() Aufruf. (Im normalen Modus werden null und undefined durch das globale Object ersetzt, und Werte, die keine Objekte sind, werden in Objekte umgewandelt.)

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

  • Im strikten Modus können Sie beim Übergeben von Code an eval() keine Variablen oder Funktionen im Gültigkeitsbereich des Aufrufers deklarieren oder definieren (wie im normalen Modus). Stattdessen wird ein neuer Bereich für eval() erstellt, und die Variablen und Funktionen befinden sich in diesem Bereich. Dieser Bereich wird zerstört, nachdem eval() die Ausführung beendet hat.
  • Im strikten Modus enthält das Argument-Objekt einer Funktion eine statische Kopie der Werte, die an diese Funktion übergeben werden. Im normalen Modus verhält sich das arguments-Objekt etwas "magisch": Die Elemente des Arrays und die benannten Funktionsparameter verweisen beide auf denselben Wert.
  • Im strikten Modus erhalten Sie ein SyntaxError, wenn auf den Operator delete ein nicht qualifizierter Bezeichner (eine Variable, eine Funktion oder ein Funktionsparameter) folgt. Im normalen Modus würde der Ausdruck delete nichts bewirken und wird zu false ausgewertet.
  • Im strikten Modus erhalten Sie ein TypeError, wenn Sie versuchen, eine nicht konfigurierbare Eigenschaft zu löschen. (Im normalen Modus schlägt der Versuch einfach fehl und der Ausdruck delete wird zu false ausgewertet.).
  • Im strengen Modus wird es als syntaktischer Fehler betrachtet, wenn Sie versuchen, mehrere Eigenschaften mit demselben Namen für ein Objektliteral zu definieren. (Im normalen Modus liegt kein Fehler vor.)
  • Im strikten Modus wird es als syntaktischer Fehler betrachtet, wenn eine Funktionsdeklaration mehrere Parameter mit demselben Namen enthält. (Im normalen Modus liegt kein Fehler vor.)
  • Im strikten Modus sind oktale Literale nicht zulässig (dies sind Literale, die mit 0x Beginnen.) (Im normalen Modus sind in einigen Implementierungen oktale Literale zulässig.)
  • Im strikten Modus werden die Bezeichner eval und arguments wie 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 strikten Modus gibt es mehr Einschränkungen für die Möglichkeiten, den Aufrufstapel zu untersuchen. arguments.caller Und arguments.callee Verursachen ein TypeError in einer Funktion im strikten Modus. Darüber hinaus verursachen einige Aufrufer- und Argumenteigenschaften von Funktionen im strikten Modus ein TypeError, wenn Sie versuchen, sie zu lesen.
92
Ely

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 ein stilles und seltsames Verhalten Ihrer Webseite verursachen können. In dem Moment, in dem wir use strict verwenden, wirft der Code Fehler aus, die dem Entwickler helfen, diese im Voraus zu beheben.

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

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 erstellt nun nameoftree im globalen Bereich, auf den mit window.nameoftree zugegriffen werden kann. Wenn wir use strict implementieren, würde der Code einen Fehler auslösen.

Nicht erfasster ReferenceError: nameoftree ist nicht definiert

Sample

Eliminiert die Anweisung with:

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

Sample

Verhindert Duplikate:

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

Nicht erfasster Syntaxfehler: Doppelte Dateneigenschaft im Objektliteral im strikten Modus nicht zulässig

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

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

80
Shubh

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

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

57
Stephen

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

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

  • Funktion in Blöcken deklarieren 

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

    var n = 023;
    
  • this zeigt auf das globale Objekt.

     function f() {
          "use strict";
          this.a = 1;
     };
     f(); 
    
  • Zweimal denselben Namen für einen Eigenschaftsnamen in einem Objektliteral deklarieren 

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

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

  • Deklarieren von zwei Funktionsargumenten mit derselben Namensfunktion 

    f(a, b, b){}
    
  • Einen Wert auf eine nicht deklarierte Variable setzen

    function f(x){
       "use strict";
       var a = 12;
       b = a + x*35; // error!
    }
    f();
    
  • Verwendung von delete für einen Variablennamen delete myVariable;

  • Verwenden Sie eval oder arguments als Variablen- oder Funktionsargumentnamen

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

Quellen:

51
zangw

Der strikte Modus nimmt einige Änderungen an der normalen JavaScript-Semantik vor:

  • beseitigt einige unbeaufsichtigte JavaScript-Fehler, indem sie geändert werden.

  • 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 vistit Strict Mode- Javascript

50
Renganathan M G

"Strict verwenden"; ist eine Versicherung, dass der Programmierer nicht die losen oder die schlechten Eigenschaften von JavaScript verwendet. Es ist eine Anleitung, genau wie ein Lineal Ihnen hilft, gerade Linien zu machen. "Strict verwenden" hilft Ihnen beim "Straight Coding".

Diejenigen, die es vorziehen, keine Lineale zu verwenden, um ihre Zeilen direkt auszuführen, enden normalerweise auf diesen Seiten und fordern andere auf, ihren Code zu debuggen.

Das können Sie mir glauben. Der Aufwand ist im Vergleich zu schlecht entworfenem Code vernachlässigbar. Doug Crockford, seit mehreren Jahren ein erfahrener JavaScript-Entwickler, hat hier einen sehr interessanten Beitrag . Ich persönlich kehre immer wieder zu seiner Website, um sicherzugehen, dass ich meine gute Praxis nicht vergesse.

Moderne JavaScript-Praktiken sollten immer "Use Strict" auslösen; Pragma Der einzige Grund, warum die ECMA-Gruppe den "Strict" -Modus optional gewählt hat ist, weniger erfahrenen Codierern Zugriff auf JavaScript zu gewähren und dann Zeit für die Anpassung an die neuen und sichereren Codierpraktiken zu geben.

48
user2436758

Die Verwendung von use strict am Anfang aller sensiblen JavaScript-Dateien von diesem Punkt aus ist ein kleiner Weg, um ein besserer JavaScript-Programmierer zu sein und zu vermeiden, dass Zufallsvariablen global werden und sich die Dinge unbemerkt ändern.

44
Placeholder

Zitat von w3schools :

Die Richtlinie "strikte Anwendung"

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

Es ist keine Anweisung, sondern ein Ausdruck, der von früheren .__ ignoriert wurde. Versionen von JavaScript.

Der Zweck von "use strict" gibt an, dass der Code .__ sein soll. im "strikten Modus" ausgeführt.

Im strikten Modus können Sie beispielsweise nicht deklarierte Variablen nicht verwenden.

Warum strikter Modus?

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

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

Bei normalem JavaScript wird durch die falsche Eingabe eines Variablennamens beispielsweise .__ erstellt. eine neue globale Variable. Im strikten Modus wird ein Fehler ausgegeben Es ist unmöglich, versehentlich eine globale Variable zu erstellen.

In normalem JavaScript erhält ein Entwickler keine Fehlermeldung Zuweisen von Werten zu nicht beschreibbaren Eigenschaften.

Im strikten Modus ist jede Zuordnung zu einer nicht beschreibbaren Eigenschaft a Nur-Getter-Eigenschaft, eine nicht vorhandene Eigenschaft, eine nicht vorhandene Variable oder ein nicht vorhandenes Objekt gibt einen Fehler aus.

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

36
Mehul Singh

"use strict" bewirkt, dass JavaScript-Code in strikter Modus ausgeführt wird. Dies bedeutet im Wesentlichen, dass vor der Verwendung alles definiert werden muss. Der Hauptgrund für den strikten Modus besteht darin, versehentliche globale Verwendung undefinierter Methoden zu vermeiden.

Auch im strikten Modus laufen die Dinge schneller, einige Warnungen oder stille Warnungen führen zu schwerwiegenden Fehlern. Es ist besser, sie immer zu verwenden, um einen ordentlicheren Code zu erstellen.

"use strict" ist weit verbreitet, um in ECMA5 verwendet zu werden. In ECMA6 ist es standardmäßig in JavaScript enthalten. Es muss also nicht hinzugefügt werden, wenn Sie ES6 verwenden.

Schauen Sie sich diese Aussagen und Beispiele von MDN an:

Die Richtlinie "strikte Anwendung"
Die Anweisung "use strict" ist neu in JavaScript 1.8.5 (ECMAScript-Version 5). Es ist keine Aussage, sondern eine Literalausdruck, von früheren JavaScript-Versionen ignoriert. Das Der Zweck von "use strict" besteht darin, anzugeben, dass der Code .__ sein sollte. im "strikten Modus" ausgeführt. Im strikten Modus können Sie beispielsweise nicht verwenden Sie nicht deklarierte Variablen.

Beispiele für die Verwendung von "use strict":
Strikter Modus für Funktionen: Ebenso den strikten Modus für eine .__ aufrufen. Funktion, setzen Sie die genaue Anweisung "use strict"; (oder 'use strict';) in den Körper der Funktion vor allen anderen Anweisungen.

1) strikter 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) strikter Modus für ganze Skripte 

'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.

32
Alireza

Einige Leute, die sich im ECMAScript-Komitee befanden, sprechen gut darüber: Änderungen an JavaScript, Teil 1: ECMAScript 5 " darüber, wie die inkrementelle Verwendung des Befehls "use strict" es JavaScript-Implementierern ermöglicht, viele der gefährlichen Funktionen von JavaScript zu entfernen ohne plötzlich jede Website der Welt zu brechen.

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

29
FutureNerd

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

Im Folgenden sind die Bedingungen zum Auslösen des strikten Modus in ES6 und ES7 aufgeführt:

  • Globaler Code ist ein strikter Moduscode, wenn er mit einem Direktive Prolog beginnt, der eine Use Strict Direktive 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 strikter Moduscode, wenn er mit einem Direktive-Prolog beginnt, der eine Use-Strict-Direktive enthält, oder wenn der Aufruf zum eval ein direktes Eval (siehe 12.3.4.1) ist, der im strengen Moduscode enthalten ist.
  • Der Funktionscode ist ein strikter Moduscode, wenn der zugehörige FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition oder ArrowFunction im strengen Moduscode enthalten ist oder wenn der Code beginnt, der den Wert des internen [[ECMAScriptCode]] - Steckplatzes der Funktion erzeugt mit einem Richtlinienprolog, der eine Use-Strict-Richtlinie enthält.
  • Der Funktionscode, der den integrierten Funktions- und Generatorkonstruktoren als Argumente bereitgestellt wird, ist ein strikter Moduscode, wenn das letzte Argument ein String ist, der bei der Verarbeitung ein FunctionBody ist, der mit einem Direktiveprolog beginnt, der eine strikte Direktive-Direktive enthält .
18
Oriol

Kleine Beispiele zum Vergleich:

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

16
Foo

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

  1. Verhindert die versehentliche Deklaration globaler Variablen. Mit "use strict()" wird sichergestellt, dass Variablen vor der Verwendung mit var 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änkung der Verwendung von Schlüsselwörtern als Variablen. Wenn Sie versuchen, sie zu verwenden, werden Fehler ausgegeben.

Kurz gesagt, wird Ihr Code weniger fehleranfällig und Sie werden wiederum dazu führen, dass Sie guten Code schreiben.

Um mehr darüber zu erfahren, können Sie hier beziehen.

11
Pritam Banerjee

"streng verwenden"; ist das Bemühen der ECMA, JavaScript etwas robuster zu machen. Es bringt in JS den Versuch, es zumindest ein wenig "streng" zu machen (andere Sprachen implementieren strikte Regeln seit den 90er Jahren). Es "zwingt" JavaScript-Entwickler, bestimmte Best Practices für das Codieren zu befolgen Dennoch ist JavaScript sehr zerbrechlich. Typisierte Variablen, typisierte Methoden usw. gibt es nicht. Ich empfehle JavaScript-Entwicklern dringend, eine robustere Sprache wie Java oder ActionScript3 zu lernen und dieselben bewährten Methoden in Ihrem JavaScript-Code zu implementieren einfacher zu debuggen.

10
PippoApps.com

use strict ist eine Möglichkeit, Ihren Code sicherer zu machen, da Sie keine gefährlichen Funktionen verwenden können, die nicht wie erwartet funktionieren können.

Strict wird verwendet, um häufige und wiederholte Fehler anzuzeigen, so dass sie unterschiedlich gehandhabt werden und die Ausführung von Java-Skripts ändert.

  • Verhindert versehentliche Globals

  • Keine Duplikate

  • Beseitigt mit

  • Beseitigt diesen Zwang

  • Sicherere Bewertung ()

  • Fehler bei unveränderlichen Objekten

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

10
Wesam

Normalerweise befolgt JavaScript keine strengen Regeln und erhöht somit das Fehlerrisiko. Nach der Verwendung von "use strict" sollte der JavaScript-Code strengen Regeln entsprechen wie in anderen Programmiersprachen, z. B. Verwendung von Terminatoren, Deklaration vor der Initialisierung usw. 

Wenn "use strict" verwendet wird, sollte der Code nach strengen Regeln geschrieben werden, wodurch die Wahrscheinlichkeit von Fehlern und Mehrdeutigkeiten verringert wird.

9

Der "strikte" Modus von JavaScript wurde in ECMAScript 5 eingeführt.

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

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

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

  2. hindert Sie daran, wichtige JS-Systembibliotheken zu überschreiben

  3. verbietet einige unsichere oder fehleranfällige Sprachfunktionen

use strict arbeitet auch innerhalb einzelner Funktionen. Es ist immer eine bessere Vorgehensweise, use strict in Ihren Code aufzunehmen.

Browserkompatibilitätsproblem: Die Direktiven "use" sind abwärtskompatibel. Browser, die sie nicht unterstützen, sehen nur ein String-Literal, auf das nicht weiter verwiesen wird. Also werden sie darüber hinweggehen und weitergehen.

8
Rabin Pantha

Strikter 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 namens name innerhalb der Funktion. Intern prüft der Compiler zunächst, ob eine Variable mit diesem bestimmten Namen in diesem bestimmten Funktionsumfang deklariert ist. Da der Compiler erkannt hat, dass es keine solche Variable gibt, wird der äußere Gültigkeitsbereich überprüft. In unserem Fall ist es der globale Geltungsbereich. Wieder hat der Compiler verstanden, dass es im globalen Raum auch keine Variable gibt, die 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 weiteres Szenario besteht darin, dass die Variable beispielsweise in einer untergeordneten Funktion deklariert wird. In diesem Fall prüft der Compiler die Gültigkeit dieser Variablen im äußeren Bereich, d. H. 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.


Nun schreiben wir die gleiche Funktion im strikten 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 Speicherverluste verhindert werden. Darüber hinaus können wir optimierten Code schreiben.

1

"streng verwenden"; Definiert, dass JavaScript-Code in .__ ausgeführt werden soll. "strikter Modus".

  • Die Anweisung "use strict" war in ECMAScript Version 5 neu.
  • Es ist keine Anweisung, sondern ein Ausdruck, der von früheren -Versionen von JavaScript ignoriert wird.
  • "Use strict" soll angeben, dass der Code Im "strikten Modus" ausgeführt werden soll.
  • Im strikten Modus können Sie beispielsweise nicht deklarierte Variablen nicht 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 strikten Modus befand, der Entwickler jedoch im Normalmodus arbeitete, ruft er möglicherweise einige Aktionen für die Bibliothek auf, die nicht wie erwartet funktionieren würden.

Da sich der Entwickler im normalen Modus befindet, hat er jedoch nicht die Vorteile, dass zusätzliche Fehler ausgelöst werden.

Wie oben aufgeführt, können Sie mit dem strikten Modus bestimmte Dinge nicht ausführen.

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 nutzen.

0
ashish

Um ganz einfach zu sein "benutze streng"; Ganz oben in Ihrer JS-Datei wird die strikte Syntaxprüfung aktiviert.

1: -Dies lässt nicht zu, dass Sie versuchen, eine nicht deklarierte Variable zuzuweisen, und zeigt einen Fehler an. 2: -Dies verhindert einige unsichere oder fehleranfällige Sprachfunktionen.

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

0
Abhijeet Singh