Was macht "use strict" in JavaScript und was sind die Gründe dafür?

Ich habe vor kurzem meinen JavaScript-Code über Crockford JSLint gestartet und es wurde folgende Fehlermeldung ausgegeben:

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

Bei einigen Recherchen wurde mir klar, dass einige Leute "use strict"; hinzufügen "use strict"; in Ihrem Javascript-Code. Sobald ich den Ausdruck hinzugefügt habe, wurde der Fehler nicht mehr angezeigt. Leider hat Google den Großteil der Geschichte dieser Betreiberlinie nicht preisgegeben. Dies sollte natürlich mit der Art und Weise zusammenhängen, wie JavaScript vom Browser interpretiert wird, aber ich weiß nicht, wie der Effekt aussehen wird.

Also, was ist "use strict"; ist alles worum es geht und ist es immer noch relevant?

Jeder aktuelle Browser antwortet auf "use strict"; String oder ist es für die zukünftige Verwendung?

6989
26 авг. gesetzt von Mark Rogers 26 aug. 2009-08-26 19:10 09 um 19:10 2009-08-26 19:10
@ 30 Antworten

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

Und auch:

Der strikte Modus hilft auf verschiedene Weise:

  • Er fängt einige gängige Programmierfehler auf und wirft Ausnahmen.
  • Es verhindert oder erzeugt Fehler, wenn relativ "unsichere" Aktionen ausgeführt werden (z. B. Zugriff auf ein globales Objekt).
  • Dies 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 (zitiert weiterhin den Artikel von John Resig):

 // Non-strict code... (function(){ "use strict"; // Define your library strictly... })(); // Non-strict code... 

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

Ich denke, es ist ein bisschen wie "use strict" Sie in Perl verwenden können (daher der Name?): Es hilft Ihnen, weniger Fehler zu machen, indem Sie mehr Dinge finden, die zu Ausfällen führen können.

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

4587
26 авг. Die Antwort gibt Pascal MARTIN 26. August. 2009-08-26 19:15 09 um 19:15 2009-08-26 19:15

Dies ist eine neue Funktion von ECMAScript 5. John Resig hat eine gute Zusammenfassung geschrieben .

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

border=0
 "use strict"; 

Die Aktivierung dieses Codes sollte bei aktuellen Browsern keine Probleme mehr verursachen, da dies nur eine Zeichenfolge ist. Dies kann in der Zukunft zu Problemen mit Ihrem Code führen, wenn Ihr Code ein Pragma verletzt. Wenn Sie beispielsweise foo = "bar" ohne zuerst foo definieren, stürzt Ihr Code ab ... was meiner Meinung nach gut ist.

1152
26 авг. die antwort ist seth 26 aug. 2009-08-26 19:14 09 um 19:14 Uhr 2009-08-26 19:14

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

Liste der Funktionen (nicht erschöpfend)

  1. Verbietet globale Variablen. (Entfernt fehlende var Deklarationen und Tippfehler in Variablennamen.)

  2. Lautlos fehlgeschlagene Aufgaben verursachen einen Fehler im strikten Modus (Zuweisung von NaN = 5; )

  3. Versuche, fehlertolerante Eigenschaften zu entfernen, führen zum delete Object.prototype ( delete Object.prototype ).

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

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

  6. Verbote - Oktalsyntax ( var x = 023; einige Entwickler glauben fälschlicherweise, dass die vorherige Null die Zahl nicht ändert.)

  7. with Keyword verbieten

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

  9. Einfache Namenslöschung deaktivieren ( delete x; )

  10. Deaktivierung der Bindung oder Benennung von eval und arguments in beliebiger Form

  11. Der strikte Modus unterstützt nicht die Eigenschaften des arguments mit Formalparametern. (d. function sum (a,b) { return arguments[0] + b;} in function sum (a,b) { return arguments[0] + b;} Dies funktioniert, weil arguments[0] mit a usw. verknüpft sind.)

  12. arguments.callee nicht unterstützt

[Link: Strikter Modus , Mozilla Developer Network]

567
25 нояб. Die Antwort wird von gprasant am 25. November gegeben. 2014-11-25 00:22 '14 am 0:22 2014-11-25 00:22

Wenn die Benutzer über use strict besorgt sind, können Sie diesen Artikel lesen:

Unterstützung des ECMAScript 5 Strict-Modus in Browsern. Was bedeutet das?
NovoGeek.com - Krishnas Blog

Es spricht von Browser-Unterstützung, aber noch wichtiger, wie man damit umgeht:

 function isStrictMode(){ return !this; }  function isStrictMode(){ "use strict"; return !this; }  
385
16 июля '12 в 2:25 2012-07-16 02:25 Die Antwort gibt Jamie Hutber am 16. Juli '12 um 02:25 Uhr 2012-07-16 02:25

Ein Wort der Vorsicht, alles, was Sie mit einer harten Aufladung programmieren: Die Anwendung von "use strict" auf vorhandenen Code kann gefährlich sein! Bei diesem Ding handelt es sich nicht um einen schönen, fröhlichen Aufkleber, den Sie auf den Code tippen können, um ihn "besser" zu machen. Mit "use strict" korrekten "use strict" Pragmas wirft der Browser plötzlich Ausnahmen an zufälligen Orten aus, die er noch nie geworfen hat, einfach weil an dieser Stelle das gemacht wird, was JavaScript für default / free erlaubt, aber kein striktes JavaScript mag ! Es kann zu strengen Verstößen kommen, die in selten verwendeten Aufrufen Ihres Codes verborgen sind. Dies führt nur dann zu einer Ausnahmebedingung, wenn sie letztendlich ausgeführt werden - beispielsweise in einer Produktionsumgebung, die Ihre Zahlungskunden verwenden!

Wenn Sie einen entscheidenden Schritt unternehmen möchten, empfehlen wir die Verwendung von "use strict" zusammen mit umfangreichen Komponententests und der streng konfigurierten JSHint-Buildaufgabe. Dies gibt Ihnen die Sicherheit, dass es keine dunklen Ecken Ihres Moduls gibt, die stark explodieren, weil Sie den strikten Modus aktiviert haben. Oder, hey, hier ist eine weitere Option: Fügen Sie keinen veralteten Code "use strict" Verwendung ein. Dies ist wahrscheinlich sicherer und ehrlicher. Fügen Sie DEFINITELN NICHT "use strict" für Module hinzu, die Sie nicht besitzen oder unterstützen, wie z. B. Module von Drittanbietern.

Ich denke, auch wenn es sich um einen tödlichen Magen in einem Käfig handelt, kann "use strict" gut sein, aber man muss es richtig machen. Die beste Zeit, um streng zu gehen, ist, wenn Ihr Projekt neu ist und Sie bei Null anfangen. JSHint/JSLint alle Warnungen und Optionen so gefaltet sind, dass Ihr Team zusammenzucken kann. Sie erhalten ein gutes Build / Test / Approval-System, das wie Grunt+Karma+Chai konfiguriert werden kann. Nur THEN wird alle Ihre neuen Module als kennzeichnen "use strict" . Seien Sie bereit, viele Fehler und Warnungen zu beheben. Stellen Sie sicher, dass alle die Schwerkraft verstehen, indem Sie die Assembly auf FAIL setzen, wenn JSHint/JSLint Unregelmäßigkeiten verursacht.

Mein Projekt war kein neues Projekt, als ich "use strict" . Infolgedessen ist meine IDE voller roter Flecken, weil ich die Hälfte meiner Module nicht "use strict" habe und JSHint sich darüber beschwert. Dies erinnert mich daran, was ich in Zukunft tun sollte. Mein Ziel ist es, wegen all meiner fehlenden "use strict" -Statements kostenlos eine rote Markierung zu erhalten. Dies ist jedoch seit vielen Jahren der Fall.

193
03 марта '14 в 10:37 2014-03-03 10:37 Die Antwort wird von DWoldrich am 3. März 14 am 10:37 am 2014-03-03 10:37 gegeben

Verwenden Sie 'use strict'; macht Ihren Code nicht besser.

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

 'use strict'; 

Wenn die JavaScript-Engine diese Anweisung erkennt, wird sie den Code in einem speziellen Modus interpretieren. In diesem Modus treten Fehler auf, wenn bestimmte Codierungsmethoden entdeckt werden, die potenzielle Fehler darstellen können (was ein Argument für den strikten Modus ist).

Betrachten Sie dieses Beispiel:

 var a = 365; var b = 030; 

In seiner Besessenheit, numerische Literale zu erstellen, initialisierte der Entwickler die Variable b achten Literal. Ein nicht strenger Modus interpretiert dies als numerisches Literal mit einem Wert von 24 (in Basis 10). Der strikte Modus führt jedoch zu einem Fehler.

Eine nicht erschöpfende Liste von Spezialitäten im strikten Modus finden Sie unter Diese Antwort .


Wo sollte ich 'use strict'; ?

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

  • In meinem vorhandenen Javascript-Code: Wahrscheinlich nicht! Wenn Ihr vorhandener JavaScript-Code Anweisungen enthält, die im strikten Modus verboten sind, wird die Anwendung einfach beschädigt. Wenn Sie den strikten Modus benötigen, sollten Sie bereit sein, vorhandenen Code zu debuggen und zu beheben. Deshalb ist die Verwendung von 'use strict'; macht Ihren Code nicht besser.


Wie verwende ich den strikten Modus?

  1. Fügen Sie 'use strict'; am oberen Rand Ihres Skripts:

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

    Bitte beachten Sie, dass alles in myscript.js im strikten Modus interpretiert wird.

  2. Oder fügen Sie 'use strict'; Die Aussage über Ihrem Körper funktioniert:

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

    Alles, was im lexikalischen Bereich der doSomething Funktion liegt, wird im strengen Modus interpretiert. Der lexikalische Bereich des Wortes ist hier wichtig. Siehe diese Antwort für eine bessere Erklärung.


Was ist strengstens verboten?

Ich habe einen guten Artikel gefunden , der einige Dinge beschreibt, die streng verboten sind (beachten Sie, dass dies keine ausschließliche Liste ist):

Volumen

In der Vergangenheit wurde JavaScript verwirrt, wie Funktionen abgedeckt werden. Manchmal scheinen sie statisch erfasst zu sein, aber einige Funktionen zwingen sie, sich so zu verhalten, als wären sie dynamisch von einer Region bedeckt. Dies ist verwirrend, was das Lesen und Verstehen von Programmen erschwert. Missverständnis verursacht Fehler. Dies ist auch ein Leistungsproblem. Eine statische Domänendefinition würde die Variablenbindung zur Kompilierzeit zulassen. Die Anforderung für eine dynamische Domäne bedeutet jedoch, dass die Bindung bis zur Laufzeit verschoben werden muss, was mit einer erheblichen Leistungsabnahme verbunden ist.

Der strikte Modus erfordert, dass alle Variablenbindungen statisch ausgeführt werden. Das bedeutet, dass Funktionen, für die zuvor eine dynamische Verknüpfung erforderlich war, eliminiert oder geändert werden müssen. Insbesondere wird der Operator mit ausgeschlossen, und die Fähigkeit von eval-Funktionen, die Umgebung seines Anrufers zu stören, ist streng begrenzt.

Strikter Code bietet den Vorteil, dass Tools wie YUI Compressor die Verarbeitung verbessern können.

Implizierte globale Variablen

JavaScript impliziert globale Variablen. Wenn Sie eine Variable nicht explizit deklarieren, wird implizit eine globale Variable für Sie deklariert. Dies vereinfacht die Programmierung für Neulinge, da sie einige ihrer wichtigsten Geschäftsaufgaben vernachlässigen können. Dies erschwert jedoch die Verwaltung größerer Programme und verringert die Zuverlässigkeit erheblich. Im strikten Modus werden implizite globale Variablen nicht mehr erstellt. Sie müssen alle Ihre Variablen explizit deklarieren.

Globale Lecks

Es gibt eine Reihe von Situationen, this dies einem globalen Objekt zugeordnet werden kann. Wenn Sie beim Aufrufen einer Konstruktorfunktion vergessen haben, new Präfix zu versehen, wird this Konstruktor unerwartet mit einem globalen Objekt verknüpft. Statt ein neues Objekt zu initialisieren, fälscht es stattdessen automatisch mit globalen Variablen. In diesen Situationen bindet der strikte Modus dies stattdessen mit undefined , wodurch der Konstruktor stattdessen eine Ausnahme auslöst und den Fehler früher erkennt.

Lauter Fehler

JavaScript hatte immer schreibgeschützte Eigenschaften. Sie konnten sie jedoch nicht selbst erstellen, bis die Object.createProperty Funktion Object.createProperty für die Object.createProperty Funktion Object.createProperty geöffnet ist. Wenn Sie versucht haben, einer schreibgeschützten Eigenschaft einen Wert zuzuweisen, schlägt dies fehl. Die Zuweisung ändert den Wert der Eigenschaft nicht, aber Ihr Programm verhält sich so, als wäre es. Dies ist eine Gefahr der Integrität, die zum Übergang von Programmen in einen inkonsistenten Zustand führen kann. Im strikten Modus führt der Versuch, die schreibgeschützte Eigenschaft zu ändern, zu einer Ausnahme.

oktal

Die 8-Bit-Darstellung von Zahlen war äußerst nützlich, wenn Sie die Maschine auf Maschinen programmieren, deren Wortgröße ein Vielfaches von 3 ist. Wenn Sie mit dem CDC 6600-Mainframe arbeiten und eine Wortgröße von 60 Bit haben, benötigen Sie eine Oktalzahl. Wenn Sie Oktal lesen könnten, könnten Sie das Wort mit 20 Ziffern betrachten. Zwei Ziffern stellten den Operationscode dar, und eine Ziffer identifizierte eines der 8 Register. Während des >

In C wurde die äußerst unglückliche Idee der Oktalität gewählt: die führende Null. In C 0100 bedeutet das also 64, nicht 100, und 08 ist ein Fehler, nicht 8. Außerdem wurde dieser Anachronismus in fast alle modernen Sprachen kopiert, einschließlich JavaScript, wo er nur zur Erzeugung von Fehlern verwendet wird. Dies hat keinen anderen Zweck. Daher sind im strengen Modus keine Oktalformen mehr zulässig.

Et cetera

Die Pseudo-Array-Argumente ähneln Arrays in ES5 eher. Im strikten Modus verliert es die Eigenschaften des callee und des caller . Dadurch können Sie Ihre arguments unzuverlässigen Code übergeben, ohne viel vertraulichen Kontext zu hinterlassen. Darüber hinaus wird die arguments von Funktionen ausgeschlossen.

Im strikten Modus geben doppelte Schlüssel in einem Funktionsliteral einen Syntaxfehler aus. Die Funktion kann nicht zwei Parameter mit demselben Namen haben. Die Funktion can nicht hat eine Variable mit demselben Namen wie einer ihrer Parameter. Die Funktion kann nicht delete hat eigene Variablen. Beim Versuch, delete nicht konfigurierbare Eigenschaft zu delete jetzt eine Ausnahme ausgelöst. Primitive Werte werden nicht implizit umbrochen.


Reservierte Wörter für zukünftige Versionen von Javascript

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

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


Lesen Sie weiter

144
29 янв. Antwort von sampathsris 29. Januar 2016-01-29 14:35 '16 am 14:35 2016-01-29 14:35

Ich empfehle dringend, dass alle Entwickler den strikten Modus 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 am Anfang 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 alle erwischt werden. Auf jeden Fall verwenden wir einfach nicht use strict in unserem Code und glauben, 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 es einfach in Ihr Skript ein und es wird schnell nach auffälligen Problemen und Fehlern in Ihrem Code durchsucht.

128
05 июля '13 в 22:38 2013-07-05 22:38 Die Antwort wird Pank am 5. Juli 13 um 10:38 Uhr 2013-07-05 22:38 gegeben

Ich möchte eine etwas fundiertere Antwort geben, die die anderen Antworten ergänzt. Ich hatte gehofft, die populärste Antwort zu bearbeiten, aber ich konnte nicht. Ich habe versucht, es so vollständig und vollständig wie möglich zu machen.

Weitere Informationen finden Sie in der MDN-Dokumentation .

"use strict" in ECMAScript 5 angegebene Direktive "use strict" .

Richtlinien sind wie Aussagen, unterscheiden sich jedoch.

  • use strict enthält keine Schlüsselwörter: Eine Direktive ist eine einfache Ausdrucksanweisung, die aus einem speziellen String-Literal besteht (in einfachen oder doppelten Anführungszeichen). JavaScript-Engines, die ECMAScript 5 nicht implementieren, sehen den Ausdruck einfach ohne Nebeneffekte. Es wird erwartet, dass zukünftige Versionen der ECMAScript-Standards die use als reales Keyword einführen. Zitate werden somit überflüssig.
  • use strict kann nur am Anfang eines Skripts oder einer Funktion verwendet werden, d. h. muss vor jeder anderen (echten) Anweisung stehen. Dies sollte nicht die erste Anweisung in einem Funktionsskript sein: Es können andere Operatorausdrücke vorangestellt werden, die aus String-Literalen bestehen (und JavaScript-Implementierungen können als spezifische Anweisungen für die Implementierung betrachtet werden). String-Literale, die auf den ersten reellen Operator (in einem Skript oder in einer Funktion) folgen, sind einfache Ausdrücke. Dolmetscher sollten sie nicht als Anweisungen interpretieren und haben keine Wirkung.

use strict Anweisung use strict zeigt an, dass der folgende Code (in einem Skript oder einer Funktion) ein strikter Code ist. Der Code auf der höchsten Ebene des Skripts (Code, der nicht in der Funktion enthalten ist) wird als strikter Code betrachtet, wenn das Skript die Anweisung use strict . Der Inhalt einer Funktion wird als strikter Code betrachtet, wenn die Funktion selbst in striktem Code definiert ist oder wenn die Funktion die Anweisung für eine use strict Anweisungen enthält. Der an die eval() -Methode übergebene Code gilt als strikter Code, wenn eval() aus einem String-Code aufgerufen wird oder die Anweisung use strict enthält.

Der ECMAScript 5-Strict-Modus ist eine begrenzte Teilmenge der JavaScript-Sprache, die die entsprechenden Sprachfehler beseitigt und eine strengere Fehlerprüfung und erhöhte Sicherheit bietet. Die folgenden sind die Unterschiede zwischen dem strikten Modus und dem normalen Modus (von denen die ersten drei besonders wichtig sind):

  • Sie können es nicht with -statement im strikten Modus verwenden.
  • Im strikten Modus müssen alle Variablen deklariert werden: Wenn Sie einem Bezeichner, der nicht als Variable, Funktion, Funktionsparameter, Catch-Klausel-Parameter oder globale Object Eigenschaft deklariert wurde, einen Wert zuweisen, wird ein ReferenceError . В нормальном режиме идентификатор объявляется неявно как глобальная переменная (как свойство глобального Object )
  • В строгом режиме ключевое слово this имеет значение undefined функции, которые были вызываться как функции ( а не как методы). (В нормальном режиме this всегда указывает на глобальный Object ). Это различие можно использовать для проверки, поддерживает ли реализация строгий режим:
 var hasStrictMode = (function() { "use strict"; return this===undefined }()); 
  • Также, когда функция вызывается с call() или apply в строгом режиме, this точно значение первого аргумента call() или apply() . (В нормальном режиме null и undefined заменяются глобальным Object а значения, которые не являются объектами, преобразуются в объекты.)

  • В строгом режиме вы получите TypeError , когда вы пытаетесь назначить свойства readonly или определить новые свойства для не растяжимого объекта. (В обычном режиме оба просто обходятся без сообщения об ошибке.)

  • В строгом режиме при передаче кода в eval() вы не можете объявлять или определять переменные или функции в области вызывающего (как это можно сделать в обычном режиме). Вместо этого для eval() создается новая область, и переменные и функции находятся в пределах этой области. Эта область уничтожается после того, как eval() завершает выполнение.
  • В строгом режиме аргумент-объект функции содержит статическую копию значений, которые передаются этой функции. В нормальном режиме аргумент-объект имеет несколько "магическое" поведение: элементы массива и именованные функциональные параметры ссылаются на одно и то же значение.
  • В строгом режиме вы получите SyntaxError когда за оператором delete следует неквалифицированный идентификатор (переменная, функция или параметр функции). В нормальном режиме выражение delete ничего не сделает и будет оценено как false .
  • В строгом режиме вы получите TypeError при попытке удалить неконфигурируемое свойство. (В обычном режиме попытка просто терпит неудачу, а выражение delete - false ).
  • В строгом режиме это считается синтаксической ошибкой при попытке определить несколько свойств с тем же именем для литерала объекта. (В нормальном режиме ошибки нет.)
  • В строгом режиме это считается синтаксической ошибкой, когда объявление функции имеет несколько параметров с тем же именем. (В нормальном режиме ошибки нет.)
  • В строгом режиме не допускаются восьмеричные литералы (это литералы, начинающиеся с 0x . (В нормальном режиме некоторые реализации позволяют делать восьмеричные литералы).
  • В строгом режиме идентификаторы eval и arguments обрабатываются как ключевые слова. Вы не можете изменить их значение, не можете присвоить им значение, и вы не можете использовать их в качестве имен для переменных, функций, параметров функций или идентификаторов блока catch.
  • В строгом режиме больше ограничений на возможности проверки стека вызовов. arguments.caller и arguments.callee вызывают TypeError в функции в строгом режиме. Кроме того, некоторые свойства caller- и аргументы функций в строгом режиме вызывают TypeError при попытке их прочитать.
88
ответ дан Ely 15 мая '15 в 9:58 2015-05-15 09:58

Мои два цента:

Одна из целей строгого режима - обеспечить более быструю отладку проблем. Это помогает разработчикам, бросая исключение, когда происходят некоторые неправильные вещи, которые могут вызвать тихое и странное поведение вашей веб-страницы. В тот момент, когда мы используем use strict , код выкидывает ошибки, которые помогают разработчику исправлять его заранее.

Немного важных вещей, которые я узнал после use strict :

Предотвращает глобальную декларацию переменных:

 var tree1Data = { name: 'Banana Tree',age: 100,leafCount: 100000}; function Tree(typeOfTree) { var age; var leafCount; age = typeOfTree.age; leafCount = typeOfTree.leafCount; nameoftree = typeOfTree.name; }; var tree1 = new Tree(tree1Data); console.log(window); 

Теперь этот код создает nameoftree в глобальной области видимости, доступ к которому можно получить с помощью window.nameoftree . Когда мы реализуем use strict использование кода, код будет вызывать ошибку.

Uncaught ReferenceError: nameoftree не определен

Sample

Исключает with утверждением:

with утверждениями не могут быть уменьшены с помощью таких инструментов, как uglify-js . Они также устарели и удалены из будущих версий JavaScript.

Sample

Предотвращает дублирование:

Когда у нас есть свойство duplicate, оно выдает исключение

Uncaught SyntaxError: Дублирование свойства данных в объектном литерале не допускается в строгом режиме

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

Есть еще несколько, но мне нужно больше узнать об этом.

77
ответ дан Shubh 21 окт. '14 в 16:31 2014-10-21 16:31

Если вы используете браузер, выпущенный в прошлом году или около того, он, скорее всего, поддерживает режим JavaScript Strict. Только старые браузеры до того, как ECMAScript 5 стал текущим стандартом, не поддерживают его.

Кавычки вокруг команды удостоверяются, что код по-прежнему будет работать и в старых браузерах (хотя вещи, которые генерируют синтаксическую ошибку в строгом режиме, как правило, просто приводят к тому, что скрипт будет работать некорректно в некоторых труднодоступных браузерах).

57
ответ дан Stephen 10 марта '12 в 6:31 2012-03-10 06:31

При добавлении "use strict"; , следующие случаи будут бросать SyntaxError перед выполнением скрипта:

  • Прокладывая путь к будущим версиям ECMAScript, используя одно из новых зарезервированных ключевых слов (в предвидении для ECMAScript 6): implements , interface , let , package , private , protected , public , static и yield .

  • Объявление функции в блоках

     if(a<b){ function f(){} } 
  • Восьмеричный синтаксис

     var n = 023; 
  • this точка относится к глобальному объекту.

      function f() { "use strict"; this.a = 1; }; f(); 
  • Объявление дважды того же имени для имени свойства в объектном литерале

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

    Это больше не относится к ECMAScript 6 ( ошибка 1041128 ).

  • Объявление двух аргументов функции с одинаковой функцией имени

     f(a, b, b){} 
  • Установка значения для необъявленной переменной

     function f(x){ "use strict"; var a = 12; b = a + x*35; // error! } f(); 
  • Использование delete для имени переменной delete myVariable;

  • Использование eval или arguments качестве имени arguments переменной или функции

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

Источники:

51
ответ дан zangw 23 дек. '15 в 6:10 2015-12-23 06:10

Строгий режим делает несколько изменений в обычной семантике JavaScript:

  • устраняет некоторые ошибки JavaScript без ошибок, изменяя их, чтобы выбросить ошибки.

  • исправляет ошибки, которые затрудняют выполнение JavaScript-движков.

  • запрещает некоторый синтаксис, который может быть определен в будущих версиях ECMAScript.

для получения дополнительной информации vistit Strict Mode- Javascript

50
ответ дан Renganathan MG 27 марта '14 в 15:18 2014-03-27 15:18

"Использовать строгий"; является страхованием, что программист не будет использовать свободные или плохие свойства JavaScript. Это руководство, точно так же, как правитель поможет вам сделать прямые линии. "Использовать Strict" поможет вам сделать "прямое кодирование".

Те, кто предпочитает не использовать правителей, чтобы делать свои строки подряд, обычно заканчиваются на тех страницах, которые требуют от других отладить свой код.

Поверь мне. Накладные расходы незначительны по сравнению с плохо разработанным кодом. У Доктора Крокфорда, который уже несколько лет является старшим разработчиком JavaScript, есть очень интересный пост . Лично мне нравится постоянно возвращаться на его сайт, чтобы я не забыл свою хорошую практику.

Современная практика JavaScript всегда должна вызывать "Use Strict"; Прагма. Единственная причина, по которой ECMA Group сделала вариант "Строгий", - это разрешить доступ менее опытным кодовым машинам к JavaScript и дать время для адаптации к новым и более безопасным способам кодирования.

48
ответ дан user2436758 31 мая '13 в 21:29 2013-05-31 21:29

Включение use strict в начале всех ваших файлов JavaScript с этого момента - это небольшой способ стать лучшим программистом JavaScript и избегать случайных переменных, становящихся глобальными, и ситуация меняется молча.

44
ответ дан Placeholder 05 сент. '14 в 15:53 2014-09-05 15:53

Цитирование из w3schools :

Директива об использовании строгих правил

Директива "use strict" появилась в JavaScript 1.8.5 (ECMAScript версии 5).

Это не утверждение, а буквальное выражение, игнорируемое более ранними версиями JavaScript.

Цель "использования строгого" - указать, что код должен выполняться в "строгом режиме".

В строгом режиме нельзя, например, использовать необъявленные переменные.

Почему строгий режим?

Строгий режим облегчает написание "безопасного" JavaScript.

Строгий режим изменяет ранее принятый "плохой синтаксис" на реальные ошибки.

Например, в обычном JavaScript неправильный ввод имени переменной создает новую глобальную переменную. В строгом режиме это приведет к ошибке, из-за которой невозможно случайно создать глобальную переменную.

В обычном JavaScript разработчик не будет получать никаких сообщений об ошибках, присваивая значения свойствам, недоступным для записи.

В строгом режиме любое присвоение недоступному для записи свойству, свойству только для получения, несуществующему свойству, несуществующей переменной или несуществующему объекту вызовет ошибку.

Пожалуйста, обратитесь к http://www.w3schools.com/js/js_strict.asp, чтобы узнать больше

36
ответ дан Mehul Singh 29 апр. '15 в 13:10 2015-04-29 13:10

"use strict" заставляет код JavaScript работать в строгом режиме, что в основном означает, что все должно быть определено перед использованием. Основная причина использования строгого режима состоит в том, чтобы избежать случайного глобального использования неопределенных методов.

Также в строгом режиме все работает быстрее, некоторые предупреждения или тихие предупреждения приводят к фатальным ошибкам, лучше всегда использовать его для создания более аккуратного кода.

"use strict" широко необходимо для использования в ECMA5, в ECMA6 это часть JavaScript по умолчанию , поэтому его не нужно добавлять, если вы используете ES6.

Посмотрите на эти заявления и примеры из MDN:

Директива об использовании строгих правил
Директива "use strict" появилась в JavaScript 1.8.5 (ECMAScript версии 5). Это не утверждение, а буквальное выражение, игнорируемое более ранними версиями JavaScript. Цель "использования строгого" - указать, что код должен выполняться в "строгом режиме". В строгом режиме нельзя, например, использовать необъявленные переменные.

Примеры использования "используйте строгий":
Строгий режим для функций: аналогично, чтобы вызвать строгий режим для функции, поместите точное выражение "use strict"; (или "используйте строгий";) в теле функции перед любыми другими утверждениями.

1) строгий режим в функциях

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

2) строгий режим всего сценария

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

3) Присвоение неписываемым глобальным

 'use strict'; // Assignment to a non-writable global var undefined = 5; // throws a TypeError var Infinity = 5; // throws a TypeError // Assignment to a non-writable property var obj1 = {}; Object.defineProperty(obj1, 'x', { value: 42, writable: false }); obj1.x = 9; // throws a TypeError // Assignment to a getter-only property var obj2 = { get x() { return 17; } }; obj2.x = 5; // throws a TypeError // Assignment to a new property on a non-extensible object. var fixed = {}; Object.preventExtensions(fixed); fixed.newProp = 'ohai'; // throws a TypeError 

Вы можете прочитать больше на MDN .

32
ответ дан Alireza 22 мая '17 в 15:38 2017-05-22 15:38

Там были хорошие разговоры некоторых людей, которые были в комитете ECMAScript: " Изменения в JavaScript, часть 1: ECMAScript 5" о том, как инкрементное использование переключателя "use strict" позволяет разработчикам JavaScript очищать множество опасных функций JavaScript без внезапно разбивая каждый сайт в мире.

Конечно, в нем также говорится о том, что такое много ошибок (и), и как ECMAScript 5 их исправляет.

29
ответ дан FutureNerd 29 марта '14 в 3:47 2014-03-29 03:47

Обратите внимание, что use strict было введено в EcmaScript 5 и хранилось с тех пор.

Ниже приведены условия для запуска строгого режима в ES6 и ES7 :

  • Глобальный код - это строгий режимный код, если он начинается с директивного пролога, содержащего директиву Use Strict (см. 14.1.1).
  • Код модуля всегда является строгим кодом режима.
  • Все части ClassDeclaration или ClassExpression являются строгим кодом режима.
  • Eval code - это строгий режимный код, если он начинается с директивы Prologue, которая содержит директиву Use Strict или если вызов eval является прямой оценкой (см. 12.3.4.1), которая содержится в коде строгого режима.
  • Функциональный код - это строгий режимный код, если связанное с ним FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition или ArrowFunction содержится в коде строгого режима, или если код, который генерирует значение внутреннего слота функций [[ECMAScriptCode]], начинается с директивы Prologue который содержит ссылку на использование Strict.
  • Код функции, который поставляется в качестве аргументов встроенным конструкторам Function и Generator, является строгим кодом режима, если последним аргументом является String, который при обработке является FunctionBody, который начинается с директивы Prologue, которая содержит директиву Strict.
18
ответ дан Oriol 12 апр. '16 в 3:25 2016-04-12 03:25

Небольшие примеры для сравнения:

Нестрогий режим:

 'use strict'; for (i of [1,2,3]) console.log(i) // output: // Uncaught ReferenceError: i is not defined 

Нестрогий режим:

 String.prototype.test = function () { 'use strict'; console.log(typeof this === 'string'); }; 'a'.test(); // output // true 
16
ответ дан Foo 22 авг. '16 в 0:43 2016-08-22 00:43

Основными причинами, по которым разработчики должны использовать "use strict" являются:

  1. Предотвращает случайное объявление глобальных переменных. "use strict()" , убедитесь, что переменные объявлены с var перед использованием. 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. NB: директива "use strict" распознается только в начале скрипта или функции.
  3. Строковые "arguments" не могут использоваться как переменная:

     "use strict"; var arguments = 3.14; // This will cause an error 
  4. Ограничит использование ключевых слов в качестве переменных. Попытки использовать их будут бросать ошибки.

Короче говоря, ваш код будет меньше подвержен ошибкам и, в свою очередь, заставит вас писать хороший код.

Чтобы узнать больше об этом, вы можете обратиться сюда .

11
ответ дан Pritam Banerjee 18 нояб. '16 в 12:53 2016-11-18 12:53

Использование Strict используется для отображения общих и повторяющихся ошибок, так что оно обрабатывается по-разному и изменяет способ запуска java-скрипта, такие изменения:

  • Предотвращает случайные глобальные переменные

  • Нет дубликатов

  • Исключает

  • Устраняет это принуждение

  • Более безопасный eval()

  • Ошибки для непременных

вы также можете прочитать эту статью за подробностями

10
ответ дан Wesam 17 окт. '16 в 16:59 2016-10-17 16:59

"использовать строгую"; это стремление ECMA сделать JavaScript немного более надежным. Это приносит JS попытку сделать его хотя бы немного "строгим" (другие языки применяют строгие правила с 90-х годов). Это на самом деле "заставляет" разработчиков JavaScript следовать некоторым передовым методам кодирования. Тем не менее, JavaScript очень хрупкий. Нет такой вещи, как типизированные переменные, типизированные методы и т.д. Я настоятельно рекомендую разработчикам JavaScript изучить более надежный язык, такой как Java или ActionScript3, и реализовать те же самые лучшие практики в вашем JavaScript-коде, он будет работать лучше и будет проще отлаживать.

10
ответ дан PippoApps.com 03 мая '16 в 15:59 2016-05-03 15:59

use strict - это способ сделать ваш код более безопасным, потому что вы не можете использовать опасные функции, которые могут работать не так, как вы ожидаете. И как было принято, прежде чем он сделает код более строгим.

10
ответ дан Просто программист 18 мая '16 в 1:31 2016-05-18 01:31

Обычно JavaScript не следует строгим правилам, что увеличивает вероятность ошибок. После использования "use strict" код JavaScript должен следовать строгому набору правил, как и в других языках программирования, таких как использование терминаторов, объявление перед инициализацией и т.д.

Если "use strict" , код должен быть написан в соответствии со строгим набором правил, что снижает вероятность ошибок и неясностей.

9
ответ дан Bikash Chapagain 20 нояб. '16 в 19:23 2016-11-20 19:23

JavaScript "строгий" режим был введен в ECMAScript 5.

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

Написание "use strict"; в самом верху вашего JS файла включается строгая проверка синтаксиса. Он выполняет следующие задачи для нас:

  1. показывает ошибку, если вы пытаетесь присвоить необъявленную переменную

  2. останавливает перезапись ключевых системных библиотек JS

  3. запрещает некоторые небезопасные или подверженные ошибкам языковые функции

use strict также работает внутри отдельных функций. Лучше всегда включать в свой код use strict .

Проблема совместимости браузера: директивы use предназначены для обратной совместимости. Браузеры, которые их не поддерживают, просто увидят строковый литерал, на который больше нет ссылок. Итак, они пройдут над ним и пойдут дальше.

8
ответ дан Rabin Pantha 11 нояб. '16 в 8:40 2016-11-11 08:40

Просто хотел добавить еще несколько очков.

Причина использования строгого Mode--->

  • Строгий режим упрощает запись "безопасного" JavaScript.

  • Строгий режим изменяет ранее принятый "плохой синтаксис" на реальный
    ошибки.

  • Например, в обычном JavaScript, обманывая имя переменной
    создает новую глобальную переменную.

  • В строгом режиме это вызовет ошибку, из-за чего невозможно случайно создать глобальную переменную.

  • В строгом режиме любое присвоение непривилегированного свойства,
    свойство getter-only, несуществующее свойство, несуществующий
    переменная или несуществующий объект, выдает ошибку.

То, что будет вызывать ошибки в строгом режиме Использование переменной, не объявляя ее, не допускается:

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

Объекты также являются переменными.

Использование объекта, не объявляя его, не допускается:

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

Удаление переменной (или объекта) запрещено.

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

По соображениям безопасности eval() не может создавать переменные в области, из которой он был вызван:

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

В вызовах функций, подобных f(), это значение является глобальным объектом. В строгом режиме он теперь не определен.

"use strict" распознается только в начале скрипта.

4
ответ дан Adds 20 февр. '17 в 22:58 2017-02-20 22:58

"использовать строгое"; Определяет, что код JavaScript должен выполняться в "строгом режиме".

  • Директива "Use strict" была впервые введена в ECMAScript версии 5.
  • Это не утверждение, а буквальное выражение, игнорируемое более ранними версиями JavaScript.
  • Цель "использования строгого" - указать, что код должен выполняться в "строгом режиме".
  • В строгом режиме нельзя, например, использовать необъявленные переменные.

Все современные браузеры поддерживают "строгое использование", кроме Internet Explorer 9 и ниже.

Недостаток

Если разработчик использовал библиотеку, которая была в строгом режиме, но разработчик привык работать в обычном режиме, они могли бы вызвать некоторые действия с библиотекой, которые не будут работать должным образом.

Хуже того, поскольку разработчик находится в обычном режиме, он не имеет преимуществ, связанных с дополнительными ошибками, поэтому ошибка может молча завершиться сбоем.

Кроме того, как указано выше, строгий режим не позволяет вам делать определенные вещи.

Люди обычно думают, что вы не должны использовать эти вещи в первую очередь, но некоторым разработчикам не нравится ограничение и они хотят использовать все возможности языка.

0
ответ дан ashish 28 янв. '19 в 13:42 2019-01-28 13:42

Строгий режим - это функция в JavaScript, которая была введена в ECMAScript 5. Она устраняет некоторые тихие ошибки JavaScript, изменяя их на ошибки. Строгий режим применяется ко всем сценариям или отдельным функциям. Это не относится к операторам блока, заключенным в фигурные скобки {}. Вы можете реализовать строгий режим, добавив "используйте строгий"; в начале сценария или функции.

Некоторые ситуации, которые выдают ошибку в строгом режиме:

  • Установка функции с одинаковыми именами параметров.
  • Создание объекта с одинаковыми ключами.
  • Тихие провальные задания.
  • Удаление простых имен или необратимых свойств
  • Установка целого числа, начинающегося с нуля, переменной

Что касается того, использовать его или нет, важно помнить следующее:

Согласно ссылке MDN ниже:

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Strict_mode

Строгий режим в браузерах

Основные браузеры теперь реализуют строгий режим. Однако не стоит слепо зависеть от этого, поскольку все еще существует множество версий браузера, которые используются в дикой природе, которые имеют лишь частичную поддержку строгого режима или вообще не поддерживают его (например, Internet Explorer ниже версии 10!). Строгий режим меняет семантику. Использование этих изменений приведет к ошибкам и ошибкам в браузерах, которые не поддерживают строгий режим. Соблюдайте осторожность при использовании строгого режима и поддерживайте зависимость от строгого режима с помощью функциональных тестов, которые проверяют, реализованы ли соответствующие части строгого режима. Наконец, обязательно протестируйте свой код в браузерах, которые поддерживают строгий режим и не поддерживают его. Если вы тестируете только в браузерах, которые не поддерживают строгий режим, у вас, скорее всего, будут проблемы в браузерах, которые поддерживают, и наоборот.

0
ответ дан alejoko 28 янв. '19 в 23:40 2019-01-28 23:40

Строгий режим - это функция в JavaScript, которая была введена в ECMAScript 5. Она устраняет некоторые тихие ошибки JavaScript, изменяя их на ошибки. Строгий режим применяется ко всем сценариям или отдельным функциям. Это не относится к операторам блока, заключенным в фигурные скобки {}. Вы можете реализовать строгий режим, добавив "используйте строгий"; в начале сценария или функции.

Некоторые ситуации, которые выдают ошибку в строгом режиме:

  • Установка функции с одинаковыми именами параметров.
  • Создание объекта с такими же ключами.
  • Тихие провальные задания.
  • Удаление простых имен или необратимых свойств
  • Установка целого числа, начинающегося с нуля, переменной

Есть некоторые браузеры, которые имеют только частичную поддержку строгого режима или не поддерживают его вообще (например, Internet Explorer ниже версии 10). Строгий режим вызовет ошибки браузеров, которые не реализуют строгий режим.

0
ответ дан alejoko 02 февр. '19 в 17:21 2019-02-02 17:21

"use strict" - строгий режим javascript, введенный в ECMA5. Это необязательно. Режим javascript по умолчанию - режим sloopy. Строгий режим добавляет некоторые строгие правила в javascript, для exp.

  1. Объявление var обязательное после строгого использования.
  2. октальная декларация не допускается, т.е. мы не можем объявлять числа, начинающиеся с 0, например, 010 не разрешено, но разрешено 10.
-1
ответ дан Avinash Malhotra 08 июля '18 в 20:18 2018-07-08 20:18

Другие вопросы по меткам или Задайте вопрос