Detaillierte Erläuterung der JavaScript-Strict-Mode_Javascript-Fähigkeiten

Wie wir wissen, ist JavaScript eine flexible Sprache. Seine Flexibilität bringt auch viele Fallstricke mit sich, und natürlich sind einige auch Designfehler. Zum Beispiel

Einer Variablen wird ein Wert ohne Deklaration zugewiesen. Der Standardwert ist eine globale Variable, z. B.

(function () {
 a = 3;
})();
console.log(window.a); // 输出3

Das Objekt verfügt über mehrere Attribute mit demselben Namen und das zuletzt zugewiesene Attribut überschreibt den vorherigen Wert. Wie zum Beispiel

var obj = {
 c: 3,
 c: 4
}
// obj 为 {c:4}

Es gibt unzählige Fallstricke wie == und typeof. Schließlich hat der Vater von JavaScript nur eine Woche damit verbracht, die Sprache zu entwerfen, haha.

Was ist der strikte Modus in JavaScript?

Im strikten Modus von JavaScript gibt es einige Einschränkungen beim Schreiben von JavaScript. Wenn diese Einschränkungen im strikten Modus verletzt werden, meldet der Code einen Fehler.

1. Übersicht

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 Einführung des „strengen Modus“ sind folgende:

- Beseitigen Sie einige unangemessene und ungenaue Aspekte der Javascript-Syntax und reduzieren Sie einige seltsame Verhaltensweisen

- Beseitigen Sie einige unsichere Aspekte des Codebetriebs und gewährleisten Sie die Sicherheit des Codebetriebs

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

- Bereiten Sie den Weg für neue Javascript-Versionen in der Zukunft.

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

Andererseits kann derselbe Code im „strikten Modus“ unterschiedliche Ausführungsergebnisse haben; einige Anweisungen, die im „normalen Modus“ ausgeführt werden können, werden im „strikten Modus“ nicht ausgeführt. 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. Eintrittsschild

Das Zeichen für den Eintritt in den „strengen Modus“ ist die folgende Zeile:

"strikt verwenden";

Ältere Versionen von Browsern behandeln es als gewöhnliche Zeichenfolge und ignorieren es.

3. So rufen Sie an

Der „strenge Modus“ verfügt über zwei Aufrufmethoden, die für verschiedene Anlässe geeignet sind.

3.1 Für die gesamte Skriptdatei

Geben Sie „use strict“ in die erste Zeile der Skriptdatei ein, und das gesamte Skript wird im „strikten Modus“ 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.

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.

<script>
  "use strict";
  console.log("这是严格模式。");
</script>
<script>
  console.log("这是正常模式。");
</script>

3.2 Für eine einzelne Funktion

Fügen Sie „use strict“ in die erste Zeile des Funktionskörpers ein, und die gesamte Funktion wird im „strengen Modus“ ausgeführt.

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

3.3 Alternative Möglichkeiten zum Schreiben von Skriptdateien

Da die erste aufrufende Methode der Dateizusammenführung nicht förderlich ist, besteht ein besserer Ansatz darin, die zweite Methode auszuleihen und die gesamte Skriptdatei in eine anonyme Funktion einzufügen, die sofort ausgeführt wird.

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

4. Grammatik- 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 einer Variablen im normalen Modus ein Wert zugewiesen wird, ohne dass sie deklariert wird, wird sie standardmäßig auf eine globale Variable gesetzt. Der strikte Modus verbietet diese Verwendung und globale Variablen müssen explizit deklariert werden.

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

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

4.2 Statische Bindung

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

Der strenge Modus erlaubt keine dynamische Bindung, sondern nur eine statische Bindung. Mit anderen Worten, zu welchem ​​Objekt die Eigenschaften und Methoden gehören, muss während der Kompilierungsphase bestimmt werden. 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) Es ist verboten, die with-Anweisung

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

（2）创设eval作用域

正常模式下，Javascript语言有两种变量作用域（scope）：全局作用域和函数作用域。严格模式创设了第三种作用域：eval作用域。

正常模式下，eval语句的作用域，取决于它处于全局作用域，还是函数作用域。严格模式下，eval语句本身就是一个作用域，不再能够生成全局变量了，它所生成的变量只能用于eval内部。

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

4.3 增强的安全措施

（1）禁止this关键字指向全局对象

function f(){
  return !this;
}
// 返回false，因为"this"指向全局对象，"!this"就是false
function f(){
  "use strict";
  return !this;
}

// 返回true，因为严格模式下，this的值为undefined，所以"!this"为true。

因此，使用构造函数时，如果忘了加new，this不再指向全局对象，而是报错。

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

（2）禁止在函数内部遍历调用栈

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

4.4 禁止删除变量

严格模式下无法删除变量。只有configurable设置为true的对象属性，才能被删除。

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

4.5 显式报错

正常模式下，对一个对象的只读属性进行赋值，不会报错，只会默默地失败。严格模式下，将报错。

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

严格模式下，对一个使用getter方法读取的属性进行赋值，会报错。

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

严格模式下，对禁止扩展的对象添加新属性，会报错。

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

严格模式下，删除一个不可删除的属性，会报错。

"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。它们也是不能使用的。

以上内容是小编给大家介绍的关于JavaScript严格模式详解的全部内容，希望大家喜欢。