Strict Mode gilt fürgesamte Skripte odereinzelne Funktionen. Er gilt nicht fürBlock-Anweisungen, die in{}-Klammern eingeschlossen sind; der Versuch, ihn auf solche Kontexte anzuwenden, hat keine Auswirkung.eval-Code,Function-Code,Ereignishandler-Attribute, Strings, die ansetTimeout() übergeben werden, und verwandte Funktionen sind entweder Funktionskörper oder gesamte Skripte, und das Aktivieren des Strict Mode in ihnen funktioniert wie erwartet.

Um den Strict Mode für ein gesamtes Skript zu aktivieren, setzen Sie dieexakte Anweisung"use strict"; (oder'use strict';) vor jede andere Anweisung.

// Whole-script strict mode syntax"use strict";const v = "Hi! I'm a strict mode script!";

Ebenso, um den Strict Mode für eine Funktion zu aktivieren, setzen Sie dieexakte Anweisung"use strict"; (oder'use strict';) im Körper der Funktion vor jede andere Anweisung.

function myStrictFunction() {  // Function-level strict mode syntax  "use strict";  function nested() {    return "And so am I!";  }  return `Hi! I'm a strict mode function! ${nested()}`;}function myNotStrictFunction() {  return "I'm not strict.";}

Die"use strict"-Direktive kann nur auf den Körper von Funktionen mit einfachen Parametern angewendet werden. Die Verwendung von"use strict" in Funktionen mitRest-,Standard- oderDestrukturierungs- Parametern ist einSyntaxfehler.

function sum(a = 1, b = 2) {  // SyntaxError: "use strict" not allowed in function with default parameter  "use strict";  return a + b;}

Der gesamte Inhalt vonJavaScript-Modulen befindet sich automatisch im Strict Mode, ohne dass eine Anweisung erforderlich ist, um ihn zu initiieren.

function myStrictFunction() {  // because this is a module, I'm strict by default}export default myStrictFunction;

Alle Teile des Körpers einerKlasse sind Strict-Mode-Code, einschließlich sowohlKlassendeklarationen als auchKlassen-Ausdrücke.

class C1 {  // All code here is evaluated in strict mode  test() {    delete Object.prototype;  }}new C1().test(); // TypeError, because test() is in strict modeconst C2 = class {  // All code here is evaluated in strict mode};// Code here may not be in strict modedelete Object.prototype; // Will not throw error

Der Strict Mode ändert sowohl die Syntax als auch das Laufzeitverhalten. Änderungen fallen im Allgemeinen in folgende Kategorien:

• Änderungen, die Fehler in Errors konvertieren (als Syntaxfehler oder zur Laufzeit)
• Änderungen, die vereinfachen, wie Variablenreferenzen aufgelöst werden
• Änderungen, dieeval undarguments vereinfachen
• Änderungen, die das Schreiben von "sicherem" JavaScript erleichtern
• Änderungen, die die zukünftige Entwicklung von ECMAScript antizipieren.

Der Strict Mode konvertiert einige vorher akzeptierte Fehler in Errors. JavaScript wurde entwickelt, um für Entwickler ohne viel Erfahrung einfach zu sein, und manchmal gibt es Operationen, die Errors sein sollten, nicht aus Fehlern bestehende Semantiken. Manchmal löst dies das unmittelbare Problem, aber manchmal schafft es schlimmere Probleme in der Zukunft. Der Strict Mode behandelt diese Fehler als Errors, sodass sie entdeckt und schnell behoben werden.

Zuweisung an nicht deklarierte Variablen

Der Strict Mode macht es unmöglich, versehentlich globale Variablen zu erstellen. Im sloppy mode erstellt das Vertippen einer Variablen bei einer Zuweisung eine neue Eigenschaft im globalen Objekt und funktioniert "weiter". Zuweisungen, die versehentlich globale Variablen erstellen würden, werfen im Strict Mode einen Fehler:

"use strict";let mistypeVariable;// Assuming no global variable mistypeVarible exists// this line throws a ReferenceError due to the// misspelling of "mistypeVariable" (lack of an "a")mistypeVarible = 17;

Fehlgeschlagene Zuweisungen an Objekteigenschaften

Der Strict Mode bewirkt, dass Zuweisungen, die ansonsten stillschweigend fehlschlagen würden, eine Ausnahme auslösen. Es gibt drei Arten, bei einer Eigenschaftenzuweisung zu scheitern:

• Zuweisung an eine nicht-schreibbare Dateneigenschaft
• Zuweisung an eine nur-getter Zugriffseigenschaft
• Zuweisung an eine neue Eigenschaft auf einemnicht-erweiterbaren Objekt

Zum Beispiel istNaN eine nicht-schreibbare globale Variable. Im sloppy mode bewirkt das Zuweisen anNaN nichts; der Entwickler erhält kein Feedback über das Scheitern. Im Strict Mode hingegen löst das Zuweisen anNaN eine Ausnahme aus.

"use strict";// Assignment to a non-writable globalundefined = 5; // TypeErrorInfinity = 5; // TypeError// Assignment to a non-writable propertyconst obj1 = {};Object.defineProperty(obj1, "x", { value: 42, writable: false });obj1.x = 9; // TypeError// Assignment to a getter-only propertyconst obj2 = {  get x() {    return 17;  },};obj2.x = 5; // TypeError// Assignment to a new property on a non-extensible objectconst fixed = {};Object.preventExtensions(fixed);fixed.newProp = "ohai"; // TypeError

Fehlgeschlagenes Löschen von Objekteigenschaften

Versuche, eine nicht-konfigurierbare oder anderweitig nicht-löschbare (z. B. wird sie von einem Proxy abgefangen, dessendeleteProperty-Handlerfalse zurückgibt) Eigenschaft zulöschen, führen im Strict Mode zu einem Fehler (wo vorher der Versuch keine Auswirkung gehabt hätte):

"use strict";delete Object.prototype; // TypeErrordelete [].length; // TypeError

Der Strict Mode verbietet auch das Löschen von einfachen Namen.delete name im Strict Mode ist ein Syntaxfehler:

"use strict";var x;delete x; // syntax error

Wenn der Name eine konfigurierbare globale Eigenschaft ist, setzen Sie ihn mitglobalThis um ihn zu löschen.

"use strict";delete globalThis.x;

Doppelte Parameternamen

Der Strict Mode erfordert, dass Funktions-Parameternamen eindeutig sind. Im sloppy mode überdeckt das letzte doppelte Argument vorher identisch benannte Argumente. Diese vorherigen Argumente bleiben überarguments verfügbar, sodass sie nicht völlig unzugänglich sind. Trotzdem macht dieses Verbergen wenig Sinn und ist wahrscheinlich unerwünscht (es könnte ein Tippfehler verstecken, zum Beispiel), daher sind doppelte Argumentnamen im Strict Mode ein Syntaxfehler:

function sum(a, a, c) {  // syntax error  "use strict";  return a + a + c; // wrong if this code ran}

Es ist auch ein Syntaxfehler im Nicht-Strict Mode, doppelte Parameternamen zu haben, wenn die Funktion ein Standard-Parameter, Rest-Parameter oder destrukturierten Parameter hat.

Alte Oktal-Literale

Der Strict Modeverbietet ein0-präfixierte Oktal-Literal. Im sloppy model wird eine Zahl, die mit0 beginnt, wie0644, als Oktalzahl (0644 === 420) interpretiert, wenn alle Ziffern kleiner als 8 sind. Entwickler ohne viel Erfahrung glauben manchmal, ein führendes Null-Präfix hat keine semantische Bedeutung, sodass sie es als Ausrichtungsgerät verwenden könnten - aber das ändert die Bedeutung der Zahl! Eine führende Null-Syntax für Oktal ist selten nützlich und kann irrtümlich verwendet werden, daher macht der Strict Mode es zu einem Syntaxfehler:

"use strict";const sum =  015 + // syntax error  197 +  142;

Die standardisierte Methode, Oktalliterale darzustellen, erfolgt über das0o-Präfix. Zum Beispiel:

const sumWithOctal = 0o10 + 8;console.log(sumWithOctal); // 16

Oktale Escape-Sequenzen, wie"\45", was"%" entspricht, können verwendet werden, um Zeichen durch erweiterte-ASCII-Zeichencodenummern in Oktal darzustellen. Im Strict Mode ist dies einSyntaxfehler. Genauer gesagt ist es nicht erlaubt,\ gefolgt von einer Dezimalziffer außer0, oder\0 gefolgt von einer Dezimalziffer zu haben; zum Beispiel\9 und\07.

Setzen von Eigenschaften auf primitive Werte

Der Strict Mode verbietet das Setzen von Eigenschaften aufprimitive Werte. Der Zugriff auf eine Eigenschaft auf einem primitiven Wert erstellt implizit ein Wrapper-Objekt, das nicht beobachtbar ist, daher wird im sloppy mode das Setzen von Eigenschaften ignoriert (no-op). Im Strict Mode wird einTypeError geworfen.

"use strict";false.true = ""; // TypeError(14).sailing = "home"; // TypeError"with".you = "far away"; // TypeError

Doppelte Eigenschaftsnamen

Doppelte Eigenschaftsnamen wurden früher im Strict Mode als einSyntaxError betrachtet. Mit der Einführung vonberechneten Eigenschaftsnamen, die Duplikation zur Laufzeit möglich machen, wurde diese Einschränkung in ES2015 aufgehoben.

"use strict";const o = { p: 1, p: 2 }; // syntax error prior to ECMAScript 2015

Der Strict Mode vereinfacht, wie Variablennamen auf bestimmte Variablendefinitionen im Code abgebildet werden. Viele Compiler-Optimierungen beruhen auf der Fähigkeit, zu sagen, dass VariableX andiesem Ort gespeichert ist: Dies ist entscheidend für die vollständige Optimierung von JavaScript-Code. JavaScript macht es manchmal unmöglich, diese grundlegende Zuordnung von Namen zu Variablendefinitionen im Code bis zur Laufzeit vorzunehmen. Der Strict Mode entfernt die meisten Fälle, in denen dies passiert, sodass der Compiler den Strict-Mode-Code besser optimieren kann.

Entfernung der with-Anweisung

Der Strict Mode verbietetwith. Das Problem beiwith besteht darin, dass jeder Name im Block entweder einer Eigenschaft des übergebenen Objekts oder einer Variable im umgebenden (oder sogar globalen) Scope zur Laufzeit zugeordnet werden könnte; es ist vorher unmöglich zu wissen, welcher. Der Strict Mode machtwith zu einem Syntaxfehler, sodass keine Chance besteht, dass ein Name inwith zur Laufzeit auf einen unbekannten Ort verweist:

"use strict";const x = 17;with (obj) {  // Syntax error  // If this weren't strict mode, would this be const x, or  // would it instead be obj.x? It's impossible in general  // to say without running the code, so the name can't be  // optimized.  x;}

Die Alternative, das Objekt einer kurzen Variablen zuzuweisen und dann auf die entsprechende Eigenschaft auf dieser Variablen zuzugreifen, ist bereit,with zu ersetzen.

Nicht-leakendes eval

Im Strict Modeführteval keine neuen Variablen in den umgebenden Scope ein. Im sloppy model führteval("var x;") eine Variablex in die umgebende Funktion oder den globalen Scope ein. Dies bedeutet, dass allgemein in einer Funktion, die einen Aufruf aneval enthält, jeder Name, der nicht auf ein Argument oder eine lokale Variable verweist, zur Laufzeit einer bestimmten Definition zugeordnet werden muss (weil dieseseval eine neue Variable eingeführt haben könnte, die die äußere Variable verdecken würde). Im Strict Mode erstellteval Variablen nur für den evaluierten Code, sodasseval nicht beeinflussen kann, ob ein Name auf eine äußere Variable oder eine lokale Variable verweist:

var x = 17;var evalX = eval("'use strict'; var x = 42; x;");console.assert(x === 17);console.assert(evalX === 42);

Ob der String, der aneval() übergeben wird, im Strict Mode ausgewertet wird, hängt davon ab, wieeval() aufgerufen wird (direct eval or indirect eval).

Block-Scoped Function Declarations

Die JavaScript-Sprachspezifikation hat von Anfang an nicht erlaubt, Funktionsdeklarationen in Block-Anweisungen zu verschachteln. Es war jedoch so intuitiv, dass die meisten Browser dies als Erweiterungsgrammatik implementierten. Leider wichen die Implementierungssemantiken voneinander ab, und es wurde unmöglich, dass die Sprachspezifikation alle Implementierungen in Einklang bringen konnte. Daher sindblock-scope Funktionsdeklarationen nur explizit im Strict Mode spezifiziert (während sie einst im Strict Mode nicht erlaubt waren), während das Verhalten im sloppy mode weiterhin abweichend zwischen den Browsern bleibt.

Der Strict Mode machtarguments undeval weniger bizarr magisch. Beide beinhalten im sloppy mode eine beträchtliche Menge an magischem Verhalten:eval, um Bindungen hinzuzufügen oder zu entfernen und Bindungswerte zu ändern, undarguments, um benannte Argumente mit seinen indizierten Eigenschaften abzugleichen. Der Strict Mode macht große Fortschritte auf dem Weg,eval undarguments als Schlüsselwörter zu behandeln.

Verhindern der Bindung oder Zuweisung von eval und arguments

Die Nameneval undarguments können nicht in der Sprachsyntax gebunden oder zugewiesen werden. Alle diese Versuche sind Syntaxfehler:

"use strict";eval = 17;arguments++;++eval;const obj = { set p(arguments) {} };let eval;try {} catch (arguments) {}function x(eval) {}function arguments() {}const y = function eval() {};const f = new Function("arguments", "'use strict'; return 17;");

Kein Abgleichen zwischen Parametern und Argument-Indizes

Strict-Mode-Code gleicht Indizes desarguments Objekts nicht mit jeder Parameterbindung ab. In einer Funktion im sloppy mode, deren erstes Argumentarg ist, setzt das Festlegen vonarg aucharguments[0], und vice versa (es sei denn, es wurden keine Argumente bereitgestellt oderarguments[0] wird gelöscht).arguments Objekte für Strict-Mode-Funktionen speichern die ursprünglichen Argumente, als die Funktion aufgerufen wurde.arguments[i] verfolgt nicht den Wert des entsprechenden benannten Arguments, noch verfolgt ein benanntes Argument den Wert in dem entsprechendenarguments[i].

function f(a) {  "use strict";  a = 42;  return [a, arguments[0]];}const pair = f(17);console.assert(pair[0] === 42);console.assert(pair[1] === 17);

Der Strict Mode macht es einfacher, "sicheres" JavaScript zu schreiben. Einige Websites bieten jetzt Möglichkeiten, mit denen Benutzer JavaScript schreiben können, das von der Website im Namen anderer Benutzer ausgeführt wird. JavaScript in Browsern kann auf die privaten Informationen des Benutzers zugreifen, daher muss solches JavaScript teilweise transformiert werden, bevor es ausgeführt wird, um den Zugriff auf verbotene Funktionalität zu verhindern. Die Flexibilität von JavaScript macht es praktisch unmöglich, dies ohne viele Laufzeit-Checks durchzuführen. Bestimmte Sprachfunktionen sind so allgegenwärtig, dass das Durchführen von Laufzeit-Checks erhebliche Leistungskosten verursacht. Ein paar Strict-Mode-Anpassungen, plus die Anforderung, dass vom Benutzer eingereichtes JavaScript Strict-Mode-Code ist und auf eine bestimmte Weise aufgerufen wird, reduzieren die Notwendigkeit für diese Laufzeit-Checks erheblich.

Keinthis-Ersatz

Der Wert, der alsthis an eine Funktion im Strict Mode übergeben wird, wird nicht gezwungen, ein Objekt zu sein (sog. "gekastet"). Für eine Funktion im sloppy mode istthis immer ein Objekt: Entweder das bereitgestellte Objekt, wenn es mit einem Objektwert alsthis aufgerufen wurde; oder der gekastete Wert vonthis, wenn es mit einem primitiven Wert alsthis aufgerufen wurde; oder das globale Objekt, wenn es mitundefined odernull alsthis aufgerufen wurde. (Verwenden Siecall,apply oderbind, um ein bestimmtesthis anzugeben.) Nicht nur ist das automatische Kasten eine Leistungskost, sondern auch das Freilegen des globalen Objekts in Browsern ist ein Sicherheitsrisiko, weil das globale Objekt Zugriff auf Funktionalität bietet, die in "sicheren" JavaScript-Umgebungen eingeschränkt werden muss. Daher wird für eine Striktmodusfunktion das angegebenethis nicht in ein Objekt gekastet, und wenn es nicht angegeben wird, istthisundefined anstelle vonglobalThis.

"use strict";function fun() {  return this;}console.assert(fun() === undefined);console.assert(fun.call(2) === 2);console.assert(fun.apply(null) === null);console.assert(fun.call(undefined) === undefined);console.assert(fun.bind(true)() === true);

Entfernung von Funktionen zum Stack-Walking

Im Strict Mode ist es nicht mehr möglich, im JavaScript-Stack zu "wandern". Viele Implementierungen implementierten zuvor einige Erweiterungsfunktionen, die es möglich machen, den upstream Aufrufer einer Funktion zu erkennen. Wenn eine Funktionfun gerade aufgerufen wird, istfun.caller die Funktion, diefun am kürzlichsten aufgerufen hat, undfun.arguments sind diearguments für diese Aufrufinstanz vonfun. Beide Erweiterungen sind problematisch für "sicheres" JavaScript, weil sie es ermöglichen, dass "gesicherten“ Code auf "privilegierte" Funktionen und deren (möglicherweise nicht gesicherte) Argumente zugreift. Wennfun im Strict Mode ist, sind sowohlfun.caller als auchfun.arguments nicht-löschbare Eigenschaften, die ein Fehler auswerfen, wenn sie gesetzt oder abgerufen werden.

function restricted() {  "use strict";  restricted.caller; // throws a TypeError  restricted.arguments; // throws a TypeError}function privilegedInvoker() {  return restricted();}privilegedInvoker();

Ebenso wirdarguments.callee nicht mehr unterstützt. Im sloppy mode verweistarguments.callee auf die umschließende Funktion. Dieser Anwendungsfall ist schwach: Benennen Sie die umschließende Funktion! Zudem behindertarguments.callee erheblich Optimierungen wie das Inlining von Funktionen, da es möglich sein muss, eine Referenz auf die nicht-inlining Funktion zu liefern, wennarguments.callee aufgerufen wird.arguments.callee für Strict-Mode-Funktionen ist eine nicht-löschbare Eigenschaft, die einen Fehler auswirft, wenn sie gesetzt oder abgerufen wird.

"use strict";function f() {  return arguments.callee;}f(); // throws a TypeError

Zusätzliche reservierte Wörter

Reservierte Wörter sind Bezeichner, die nicht als Variablennamen verwendet werden können. Der Strict Mode reserviert einige Namen mehr als der sloppy mode, von denen einige bereits in der Sprache verwendet werden und einige für die Zukunft reserviert sind, um die Implementierung zukünftiger Syntaxerweiterungen zu erleichtern.

• implements
• interface
• let
• package
• private
• protected
• public
• static
• yield

Der Strict Mode wurde so konzipiert, dass der Übergang dazu schrittweise erfolgen kann. Es ist möglich, jede Datei einzeln zu ändern und selbst Code auf der Funktionsebene schrittweise in den Strict Mode zu überführen.

Sie können eine Codebasis auf den Strict Mode umstellen, indem Sie zuerst"use strict" zu einem Teil des Quellcodes hinzufügen und dann alle Ausführungsfehler beheben, während Sie auf semantische Unterschiede achten.

Wenn Sie'use strict'; hinzufügen, führen die folgenden Fälle vor der Skriptausführung zu einemSyntaxError:

• Oktal-Syntaxconst n = 023;
• with-Anweisung
• Verwendung vondelete auf einem Variablennamendelete myVariable;
• Verwendung voneval oderarguments als Variablen- oder Funktionsargumentname
• Verwendung eines der neureservierten Schlüsselwörter (in Erwartung zukünftiger Sprachfunktionen):implements,interface,let,package,private,protected,public,static undyield
• Deklarieren von zwei Funktionsparametern mit demselben Namenfunction f(a, b, b) {}
• Deklarieren desselben Eigenschaftsnamen zweimal in einem Objektliteralen{a: 1, b: 3, a: 7}. Diese Einschränkung wurde später entfernt (bug 1041128).

Diese Fehler sind gut, weil sie auf Fehler oder schlechte Praktiken hinweisen. Sie treten auf, bevor der Code ausgeführt wird, und sind daher leicht zu entdecken, solange der Code vom Laufzeitsystem analysiert wird.

JavaScript war früher dazu geneigt, in Kontexten stillschweigend zu scheitern, in denen das, was getan wurde, ein Fehler sein sollte. Der Strict Mode wirft in solchen Fällen einen Fehler. Wenn Ihre Codebasis solche Fälle enthält, sind Tests notwendig, um sicherzustellen, dass nichts beschädigt wird. Sie können solche Fehler auf der Funktionsebene aufspüren.

• Das Zuweisen zu einer nicht deklarierten Variablen wirft einenReferenceError. Früher setzte dies eine Eigenschaft im globalen Objekt, was selten der erwartete Effekt ist. Wenn Sie wirklich einen Wert im globalen Objekt setzen möchten, weisen Sie ihn explizit als Eigenschaft vonglobalThis zu.
• Das Scheitern einer Zuweisung an eine Objekteigenschaft (z. B. es ist schreibgeschützt) wirft einenTypeError. Im sloppy model würde dies stillschweigend fehlschlagen.
• Das Löschen einer nicht-löschbaren Eigenschaft wirft einenTypeError. Im sloppy model würde dies stillschweigend fehlschlagen.
• Der Zugriff aufarguments.callee,strictFunction.caller oderstrictFunction.arguments wirft einenTypeError, wenn die Funktion im Strict Mode ist. Wenn Siearguments.callee verwenden, um die Funktion rekursiv aufzurufen, können Sie stattdessen einen benannten Funktionsausdruck verwenden.

Diese Unterschiede sind sehr subtile Unterschiede. Es ist möglich, dass eine Test-Suite solche subtile Unterschiede nicht entdeckt. Eine sorgfältige Überprüfung Ihrer Codebasis wird wahrscheinlich notwendig sein, um sicherzustellen, dass diese Unterschiede die Semantik Ihres Codes nicht beeinflussen. Glücklicherweise kann diese sorgfältige Überprüfung schrittweise bis zur Funktionsebene erfolgen.

this

Im sloppy model würden Funktionsaufrufe wief() das globale Objekt alsthis-Wert übergeben. Im Strict Mode ist es jetztundefined. Wenn eine Funktion mitcall oderapply aufgerufen wurde, wenn der Wert ein primitiver Wert war, wurde dieser in ein Objekt gekastet (oder das globale Objekt fürundefined undnull). Im Strict Mode wird der Wert direkt ohne Konvertierung oder Ersatz übergeben.

arguments

Im sloppy model führte das Ändern eines Werts imarguments-Objekt zu einer Änderung des entsprechenden benannten Arguments. Dadurch wurden Optimierungen für die JavaScript-Engine komplizierter und der Code schwerer lesbar/nachvollziehbar. Im Strict Mode wird dasarguments-Objekt erstellt und mit denselben Werten wie die benannten Argumente initialisiert, jedoch werden Änderungen entweder amarguments-Objekt oder an den benannten Argumenten nicht gegenseitig reflektiert.

eval

Im Strict Mode-Code erstellteval keine neue Variable im Scope, aus dem es aufgerufen wurde. Natürlich wird auch der String im Strict Mode mit den Regeln des Strict Mode ausgewertet. Gründliche Tests sind erforderlich, um sicherzustellen, dass nichts beschädigt wird.eval nicht zu verwenden, wenn es nicht wirklich notwendig ist, kann eine andere pragmatische Lösung sein.

Block-scope Funktionsdeklarationen

Im sloppy model kann eine Funktionsdeklaration innerhalb eines Blocks außerhalb des Blocks sichtbar und sogar aufrufbar sein. Im Strict Mode ist eine Funktionsdeklaration innerhalb eines Blocks nur innerhalb des Blocks sichtbar.

• Leitfaden zu JavaScript-Modulen
• Lexikalische Grammatik