Ein direkter Blick auf den strikten Modus von Javascript („use strict“)

Detaillierte Erklärung des strikten Javascript-Modus („strikt verwenden“)

Teilen:

In Zusätzlich zum normalen Laufmodus fügt ECMAscript 5 einen zweiten Laufmodus hinzu: „Strict Mode“. Wie der Name schon sagt, führt dieser Modus dazu, dass Javascript unter strengeren Bedingungen ausgeführt wird.

Die Hauptziele der Einrichtung des „strengen Modus“ sind folgende:

- Eliminierung einiger unangemessener und lockerer Aspekte der Javascript-Syntax und Reduzierung einiger seltsamer Verhaltensweisen;

– Beseitigen Sie einige Unsicherheiten bei der Codeausführung und stellen Sie die Sicherheit der Codeausführung sicher.

– Verbessern Sie die Compiler-Effizienz und erhöhen Sie die Ausführungsgeschwindigkeit.

„Strict Mode“ spiegelt die vernünftigere, sicherere und strengere Entwicklungsrichtung von Javascript wider, einschließlich IE 10, und viele große Projekte haben damit begonnen, es vollständig zu übernehmen .

Andererseits kann derselbe Code im „strikten Modus“ zu unterschiedlichen Ausführungsergebnissen führen. Einige Anweisungen, die im „normalen Modus“ ausgeführt werden können, können im „strikten Modus“ nicht ausgeführt werden. Wenn Sie diese Inhalte beherrschen, können Sie Javascript besser verstehen und ein besserer Programmierer werden.

In diesem Artikel wird der „strenge Modus“ ausführlich vorgestellt.

2. Eingabeflag

Das Zeichen zum Aufrufen des „strengen Modus“ ist die folgende Zeile:

　"use strict";

Ältere Versionen von Browsern behandeln es als eine Zeile mit gewöhnlichen Zeichen , ignoriere es.

3. So rufen Sie an

Es gibt zwei Anrufmethoden für den „strengen Modus“, die für unterschiedliche Anlässe geeignet sind.

3.1 Für die gesamte Skriptdatei

geben Sie „use strict“ in die erste Zeile der Skriptdatei ein, dann wird das gesamte Skript im „strict mode“ ausgeführt. Wenn diese Anweisungszeile nicht die erste Zeile ist, ist sie ungültig und das gesamte Skript wird im „Normalmodus“ ausgeführt. Dies erfordert besondere Aufmerksamkeit, wenn Codedateien aus verschiedenen Modi in einer Datei zusammengeführt werden.

(Genau genommen muss „use strict“ nicht in der ersten Zeile stehen, z. B. direkt nach einem leeren Semikolon, solange es sich bei der vorhergehenden Anweisung nicht um eine Anweisung handelt, die tatsächliche Operationsergebnisse liefert.)

<script>
"use strict";
console.log("这是严格模式。");
</script>
<script>
console.log("这是正常模式。");kly, it&#39;s almost 2 years ago now. I can admit it now - I run it on my school&#39;s network that has about 50 computers.
</script>

Der obige Code zeigt an, dass eine Webseite zwei Teile Javascript-Code enthält. Das erstere Skript-Tag befindet sich im strikten Modus, das letztere jedoch nicht.

3.2 Für eine einzelne Funktion

geben Sie „use strict“ in die erste Zeile des Funktionskörpers ein, dann wird die gesamte Funktion im „strict mode“ ausgeführt.

function strict(){
"use strict";
return "这是严格模式。";
}
function notStrict() {
return "这是正常模式。";
}

3.3 Alternative Art, Skriptdateien zu schreiben

Da die erste aufrufende Methode nicht zum Zusammenführen von Dateien geeignet ist, besteht ein besserer Ansatz darin, die zweite Methode auszuleihen und die gesamte Skriptdatei in einer einzigen Datei unterzubringen eine anonyme Funktion, die sofort ausgeführt wird.

(function (){
"use strict";
// some code here
})();

4. Syntax- und Verhaltensänderungen

Der strikte Modus hat einige Änderungen an der Syntax und dem Verhalten von Javascript vorgenommen.

4.1 Explizite Deklaration globaler Variablen

Wenn im Normalmodus einer Variablen ein Wert zugewiesen wird, ohne deklariert zu werden, ist die Standardeinstellung eine globale Variable. Der strikte Modus verbietet diese Verwendung und globale Variablen müssen explizit deklariert werden.

"use strict";
v = 1; // 报错，v未声明
for(i = 0; i < 2; i++) { // 报错，i未声明
}

Daher müssen Variablen im strikten Modus vor der Verwendung mit dem Befehl var deklariert werden.

4.2 Statische Bindung

Ein Merkmal der Javascript-Sprache ist, dass sie eine „dynamische Bindung“ ermöglicht, d. h., zu welchem ​​Objekt bestimmte Eigenschaften und Methoden gehören, wird nicht zur Kompilierungszeit bestimmt, sondern wird zur Laufzeit ermittelt.

Der strenge Modus erlegt der dynamischen Bindung einige Einschränkungen auf. In einigen Fällen ist nur statische Bindung zulässig. Mit anderen Worten: Zu welchem ​​Objekt die Eigenschaften und Methoden gehören, wird während der Kompilierungsphase bestimmt. Dies trägt dazu bei, die Kompilierungseffizienz zu verbessern, den Code leichter lesbar zu machen und weniger Überraschungen zu verursachen.

Konkret geht es dabei um die folgenden Aspekte.

(1) Die Verwendung der with-Anweisung

ist verboten, da die with-Anweisung zur Kompilierungszeit nicht bestimmen kann, zu welchem ​​Objekt das Attribut gehört.

"use strict";
var v = 1;
with (o){ // 语法错误
v = 2;
}

(2) Auswertungsbereich erstellen

Im normalen Modus verfügt die Javascript-Sprache über zwei Variablenbereiche: den globalen Bereich und den Funktionsbereich. Der strikte Modus erstellt einen dritten Bereich: den Auswertungsbereich.

Im Normalmodus hängt der Umfang der eval-Anweisung davon ab, ob sie sich im globalen Bereich oder im Funktionsbereich befindet. Im strikten Modus ist die eval-Anweisung selbst ein Bereich und kann keine globalen Variablen mehr generieren. Die von ihr generierten Variablen können nur innerhalb von eval verwendet werden.

"use strict";
var x = 2;
console.info(eval("var x = 5; x")); // 5
console.info(x); // 2

4.3 Erweiterte Sicherheitsmaßnahmen

(1) Verhindern Sie, dass das Schlüsselwort „this“ auf das globale Objekt verweist.

function f(){
return !this;
}
// 返回false，因为"this"指向全局对象，"!this"就是false
function f(){
"use strict";
return !this;
}
// 返回true，因为严格模式下，this的值为undefined，所以"!this"为true。

Wenn Sie daher bei Verwendung des Konstruktors vergessen, „new“ hinzuzufügen , zeigt dies dann nicht auf das globale Objekt, es wird jedoch ein Fehler gemeldet.

function f(){
"use strict";
this.a = 1;
};
f();// 报错，this未定义

(2) Es ist verboten, den Aufrufstapel innerhalb der Funktion zu durchlaufen

function f1(){
"use strict";
f1.caller; // 报错
f1.arguments; // 报错
}
f1();

4.4 Es ist verboten, Variablen zu löschen

Variablen können im strikten Modus nicht gelöscht werden. Es können nur Objektattribute gelöscht werden, deren konfigurierbare Eigenschaft auf „true“ gesetzt ist.

"use strict";
var x;
delete x; // 语法错误
var o = Object.create(null, {'x': {
value: 1,
configurable: true
}});
delete o.x; // 删除成功

4.5 Explizite Fehlerberichterstattung

Im normalen Modus wird beim Zuweisen eines Werts zu einer schreibgeschützten Eigenschaft eines Objekts kein Fehler gemeldet, sondern es schlägt stillschweigend fehl. Im strikten Modus wird ein Fehler gemeldet.

"use strict";
var o = {};
Object.defineProperty(o, "v", { value: 1, writable: false });
o.v = 2; // 报错

Im strikten Modus wird ein Fehler gemeldet, wenn einem mit der Getter-Methode gelesenen Attribut ein Wert zugewiesen wird.

"use strict";
var o = {
get v() { return 1; }
};
o.v = 2; // 报错

Im strikten Modus führt das Hinzufügen neuer Attribute zu Objekten, deren Erweiterung verboten ist, zu einem Fehler.

"use strict";
var o = {};
Object.preventExtensions(o);
o.v = 1; // 报错

Im strikten Modus führt das Löschen eines Attributs, das nicht gelöscht werden kann, zu einem Fehler.

"use strict";
delete Object.prototype; // 报错

4.6 重名错误

严格模式新增了一些语法错误。

（1）对象不能有重名的属性

正常模式下，如果对象有多个重名属性，最后赋值的那个属性会覆盖前面的值。严格模式下，这属于语法错误。

"use strict";
var o = {
p: 1,
p: 2
}; // 语法错误

（2）函数不能有重名的参数

正常模式下，如果函数有多个重名的参数，可以用arguments[i]读取。严格模式下，这属于语法错误。

"use strict";
function f(a, a, b) { // 语法错误
return ;
}

4.7 禁止八进制表示法

正常模式下，整数的第一位如果是0，表示这是八进制数，比如0100等于十进制的64。严格模式禁止这种表示法，整数第一位为0，将报错。

"use strict";
var n = 0100; // 语法错误

4.8 arguments对象的限制

arguments是函数的参数对象，严格模式对它的使用做了限制。

（1）不允许对arguments赋值

"use strict";
arguments++; // 语法错误
var obj = { set p(arguments) { } }; // 语法错误
try { } catch (arguments) { } // 语法错误
function arguments() { } // 语法错误
var f = new Function("arguments", "'use strict'; return 17;"); // 语法错误

（2）arguments不再追踪参数的变化

　function f(a) {
a = 2;
return [a, arguments[0]];
}
f(1); // 正常模式为[2,2]
function f(a) {
"use strict";
a = 2;
return [a, arguments[0]];
}
f(1); // 严格模式为[2,1]

（3）禁止使用arguments.callee

这意味着，你无法在匿名函数内部调用自身了。

"use strict";
var f = function() { return arguments.callee; };
f(); // 报错

4.9 函数必须声明在顶层

将来Javascript的新版本会引入”块级作用域”。为了与新版本接轨，严格模式只允许在全局作用域或函数作用域的顶层声明函数。也就是说，不允许在非函数的代码块内声明函数。

"use strict";
if (true) {
function f() { } // 语法错误
}
for (var i = 0; i < 5; i++) {
function f2() { } // 语法错误
}

4.10 保留字

为了向将来Javascript的新版本过渡，严格模式新增了一些保留字：implements, interface, let, package, private, protected, public, static, yield。

使用这些词作为变量名将会报错。

function package(protected) { // 语法错误
"use strict";
var implements; // 语法错误
}

此外，ECMAscript第五版本身还规定了另一些保留字（class, enum, export, extends, import, super），以及各大浏览器自行增加的const保留字，也是不能作为变量名的。

推荐教程：《js基础教程》

Das obige ist der detaillierte Inhalt vonEin direkter Blick auf den strikten Modus von Javascript („use strict“). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!