Detaillierte Erklärung des strikten Modus in JavaScript

Einführung

In ES5 wurde der strikte Modus eingeführt, den wir strikten Modus nennen können. Der entsprechende Sloppy-Modus kann als nicht strikter Modus bezeichnet werden.

Der strikte Modus ist keine Teilmenge des nicht strikten Modus. Im Gegenteil, der strikte Modus weist einige semantische Unterschiede zum nicht strikten Modus auf, sodass wir bei der Verwendung strenge Tests durchführen müssen. Um sicherzustellen, dass die Ausführung des Programms im strengen Modus mit der Ausführung im nicht strengen Modus übereinstimmt.

Verwenden des strikten Modus

Der strikte Modus ändert einige Verhaltensweisen von JavaScript, was wir im nächsten Abschnitt ausführlich erläutern werden.

Sehen wir uns an, wie der strikte Modus verwendet wird.

Der strenge Modus wird hauptsächlich in einem vollständigen Skript oder einer vollständigen Funktion verwendet und gilt nicht für den Block {}. Wenn Sie in einem Block den strikten Modus verwenden, wird dieser nicht wirksam.

Darüber hinaus können der Code in eval, der Funktionscode, das Ereignishandlerattribut und die an WindowTimers.setTimeout() übergebene Zeichenfolge alle als vollständiges Skript betrachtet werden. Wir können darin den strengen Modus verwenden.

Wenn Sie in einem Skript den strikten Modus verwenden, können Sie „use strict“ direkt oben im Skript hinzufügen:

// Strenger Modus für das gesamte Skript „use strict“;
var v = "Hallo! Ich bin ein Skript im strikten Modus!";

In ähnlicher Weise können wir auch den strikten Modus in der Funktion verwenden:

Funktion streng() {
  // Strikter Modus der Funktion „use strict“;
  function nested() { return 'Und ich auch!'; }
  return "Hallo! Ich bin eine Funktion im strikten Modus! " + nested();
}
function notStrict() { return "Ich bin nicht streng."; }

Wenn Sie in ES6 eingeführte Module verwenden, befinden sich die Module standardmäßig bereits im strikten Modus und wir müssen „use strict“ nicht zusätzlich verwenden:

Funktion meinModul() {
    // Der Standard ist der strikte Modus}
exportiere standardmäßig meinModul;

Neue Features im strikten Modus

Der strikte Modus weist im Vergleich zum nicht strikten Modus einige Unterschiede in Syntax und Laufzeitleistung auf. Als Nächstes sehen wir uns diese nacheinander an.

Auslösen einer Ausnahme erzwingen

In js gibt es viele Fälle, in denen der Vorgang möglicherweise falsch ist, aufgrund der Eigenschaften der Sprache jedoch keine Ausnahme ausgelöst wird, was dazu führt, dass das endgültige Laufergebnis nicht Ihren Erwartungen entspricht.

Wenn der strikte Modus verwendet wird, wird direkt eine Ausnahme ausgelöst.

Beispielsweise sind im strikten Modus undefinierte globale Variablen nicht zulässig:

„streng verwenden“;

globalVar = 10; //Referenzfehler: globalVar ist nicht definiert

Dadurch können tatsächlich Probleme vermieden werden, die durch die versehentliche Eingabe des falschen Variablennamens entstehen.

Lassen Sie mich einige andere Beispiele betrachten:

„streng verwenden“;

// Einer nicht beschreibbaren globalen Variable zuweisen,
var undefined = 5; // wirft einen TypeError
var Infinity = 5; // wirft einen TypeError

// Einer nicht beschreibbaren Eigenschaft einen Wert zuweisen var obj1 = {};
Object.defineProperty(obj1, 'x', { Wert: 42, beschreibbar: false });
obj1.x = 9; // wirft einen TypeError

// Einer Get-Methode einen Wert zuweisen var obj2 = { get x() { return 17; } };
obj2.x = 5; // wirft einen TypeError

// Zuweisung zu einem Objekt, das keine Erweiterung zulässt var fixed = {};
Objekt.preventExtensions(behoben);
fixed.newProp = 'ohai'; // wirft einen TypeError

Der strikte Modus kann das Löschen nicht löschbarer Eigenschaften einschränken, beispielsweise des Prototyps des Konstruktors:

„streng verwenden“;
lösche Object.prototype; // wirft einen TypeError

Verbieten Sie doppelte Eigenschaften in Objekten und Funktionsparametern:

„streng verwenden“;
var o = { p: 1, p: 2 }; // Doppelte Deklaration

function sum(a, a, c) { // Doppelte Deklaration
    „streng verwenden“;
    gebe a + a + c zurück;
}

Das Setzen von Eigenschaften primitiver Typen ist verboten:

(Funktion() {
„streng verwenden“;

false.true = ''; // Typfehler
(14).sailing = 'home'; // Typfehler
'mit'.dir = 'weit weg'; // TypeError

})();

Vereinfachen Sie die Verwendung von Variablen

Die Verwendung des strikten Modus kann die Verwendung von Variablen vereinfachen und den Programmcode lesbarer machen.

Erstens verbietet der strikte Modus die Verwendung von „with“.

with ist sehr leistungsfähig. Wir können ein Objekt an with übergeben, um die Gültigkeitskette der Variablensuche zu beeinflussen. Das heißt, wenn wir ein bestimmtes Attribut im with-Block verwenden müssen, suchen wir zusätzlich zur Suche in der vorhandenen Bereichskette auch in dem von with übergebenen Objekt.

mit (Ausdruck)
  Stellungnahme

Die Verwendung von „with“ dient normalerweise der Vereinfachung unseres Codes, beispielsweise:

var a, x, y;
var r = 10;

mit (Mathe) {
  a = PI * r * r;
  x = r * cos(PI);
  y = r * sin(PI / 2);
}

Im obigen Beispiel ist PI eine Variable im Math-Objekt, aber wir können sie direkt im With-Block verwenden. Es fühlt sich ein bisschen wie Import in Java an.

Das folgende Beispiel zeigt das Problem der Verwendung mit:

Funktion f(x, o) {
  mit (o) {
    console.log(x);
  }
}

Wir geben die x-Variable im with-Block aus. Aus dem Code können wir erkennen, dass die f-Funktion eine x-Variable übergibt. Wenn das von with verwendete Objekt jedoch auch über ein x-Attribut verfügt, treten unerwartete Probleme auf.

Daher ist mit im strengen Modus verboten.

Die zweite ist die Änderung zu eval.

Im herkömmlichen Modus werden in eval definierte Variablen automatisch dem Bereich hinzugefügt, der eval enthält. Schauen wir uns ein Beispiel an:

var x = 17;
var evalX = eval("var x = 42; x;");
console.log(x);

Da die neue Variable x in eval eingeführt wird, überschreibt der Wert von x das ursprünglich definierte x=17. Schließlich erhalten wir das Ergebnis 42.

Wenn „use strict“ hinzugefügt wird, werden die Variablen in eval nicht zum vorhandenen Bereich hinzugefügt und wir erhalten das Ergebnis 17.

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

Der Vorteil hierbei besteht darin, dass die Auswirkungen der Auswertung auf die vorhandene Programmlogik vermieden werden.

Im strikten Modus ist das Löschen von Namen nicht zulässig:

„streng verwenden“;

var x;
delete x; // !!! Syntaxfehler

eval('var y; delete y;'); // !!! Syntaxfehler~~

Argumente vereinfachen

In js stellen Argumente ein Array von Parametern dar. Zunächst einmal können im strikten Modus Argumente nicht als Variablennamen zugewiesen werden:

„streng verwenden“;
Argumente++;
var obj = { setze p(Argumente) { } };
versuche { } fange (Argumente) { }
Funktionsargumente() { }
var f = neue Funktion('Argumente', "'use strict'; return 17;");

Die obige Ausführung meldet einen Fehler.

Darüber hinaus sind im Normalmodus die Argumente an die benannten Parameter gebunden und die Argumente[0] und arg ändern sich synchron, wobei beide den ersten Parameter angeben.

Im strikten Modus stellen die Argumente jedoch die tatsächlich übergebenen Parameter dar.

Nehmen wir ein Beispiel:

Funktion f(a) {
    ein = 42;
    returniere [a, Argumente[0]];
}
var Paar = f(17);
console.log(paar[0]); // 42
console.log(paar[1]); // 42

Im obigen Beispiel ist arguments[0] an den benannten Parameter a gebunden. Unabhängig davon, welcher Wert an f übergeben wird, ist der Endwert von arguments[0] 42.

Wenn Sie in den strikten Modus wechseln:

Funktion f(a) {
    „streng verwenden“;
    ein = 42;
    returniere [a, Argumente[0]];
}
var Paar = f(17);
console.log(paar[0]); // 42
konsole.log(paar[1]); // 17

In diesem Modus empfängt arguments[0] die tatsächlich übergebenen Parameter und wir bekommen das Ergebnis 17.

Im strengen Modus ist arguments.callee deaktiviert. Im Allgemeinen verweist arguments.callee auf die aktuell ausgeführte Funktion, was die virtuelle Maschine daran hindert, die Inlining-Optimierung zu optimieren, sodass dies im strikten Modus verboten ist.

JavaScript sicherer machen

Wenn wir dies im Normalmodus in einer Funktion f() aufrufen, bezieht sich dies auf das globale Objekt. Im strengen Modus ist der Wert undefiniert.

Wenn wir es über „call“ oder „apply“ aufrufen und der primitive Wert (Basistyp) übergeben wird, zeigt dieser im Normalmodus automatisch auf seine Box-Klasse (den Objekttyp, der dem primitiven Typ entspricht, z. B. Boolean, Number usw.). Wenn „undefined“ oder „null“ übergeben wird, bezieht sich dies auf das globale Objekt.

Im strikten Modus bezieht sich dies auf den übergebenen Wert und es wird keine Konvertierung oder Transformation durchgeführt.

Die folgenden Werte sind alle wahr:

„streng verwenden“;
Funktion fun() { gib dies zurück; }
Konsole.Assert(Spaß() === undefiniert);
Konsole.Assert(Spaß.Call(2) === 2);
console.assert(fun.apply(null) === null);
Konsole.Assert(fun.call(undefiniert) === undefiniert);
Konsole.Assert(Spaß.Bind(true)() === true);

Warum ist es sicher? Dies bedeutet, dass Sie im strengen Modus dies nicht verwenden können, um auf das Fensterobjekt zu verweisen, wodurch die Sicherheit des Programms gewährleistet wird.

Darüber hinaus können wir im normalen Modus den Aufrufer und die Parameter der Funktion über fun.caller oder fun.arguments abrufen, die möglicherweise auf einige private Eigenschaften oder unsichere Variablen zugreifen und so Sicherheitsprobleme verursachen.

Im strikten Modus sind fun.caller oder fun.arguments verboten.

Funktion eingeschränkt() {
  „streng verwenden“;
  eingeschränkter.Anrufer; // wirft einen TypeError
  eingeschränkte.Argumente; // wirft einen TypeError
}
Funktion privilegierterInvoker() {
  Rückgabe eingeschränkt();
}
privilegierterInvoker();

Reservierte Schlüsselwörter und Funktionspositionen

Um die spätere Entwicklung von JS-Standards sicherzustellen, dürfen Schlüsselwörter im strikten Modus nicht als Variablennamen verwendet werden. Zu diesen Schlüsselwörtern gehören implements, interface, let, package, private, protected, public, static und yield.

Funktionspaket (geschützt) { // !!!
  „streng verwenden“;
  var implementiert; // !!!

  Schnittstelle: // !!!
  während (wahr) {
    Schnittstelle unterbrechen; // !!!
  }

  Funktion privat() { } // !!!
}
Funktion Spaß (statisch) { 'streng verwenden'; } // !!!

Was Funktionen betrifft, können sie im normalen Modus überall definiert werden, im strikten Modus jedoch nur auf der obersten Ebene des Skripts oder innerhalb einer Funktion:

„streng verwenden“;
wenn (wahr) {
  function f() { } // !!! Syntaxfehler
  F();
}

für (var i = 0; i < 5; i++) {
  function f2() { } // !!! Syntaxfehler
  f2();
}

Funktion baz() { // koscher
  function eit() { } // auch koscher
}

Zusammenfassen

Der strikte Modus hat bei der nachfolgenden Entwicklung von JS und der Standardisierung bestehender Programmiermodelle eine sehr wichtige Rolle gespielt. Wenn wir es jedoch browserseitig verwenden, müssen wir dennoch auf die Kompatibilität des Browsers achten und strenge Tests durchführen.

Oben finden Sie eine ausführliche Erläuterung des strikten Modus in JavaScript. Weitere Informationen zum strikten Modus in JavaScript finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!