Eine kurze Analyse dessen, was Sie über den strikten Modus in js wissen müssen

Der Inhalt dieses Artikels ist eine kurze Analyse dessen, was zum Beherrschen des strengen Modus in js erforderlich ist. Ich hoffe, dass er für Sie hilfreich ist.

Strenger Modus

Lassen Sie uns zunächst verstehen, was ein strikter Modus ist.
Der strikte Modus ist eine restriktivere Variante von JavaScript und keine Teilmenge: Er unterscheidet sich semantisch erheblich vom normalen Code, Browsern, die den strikten Modus nicht unterstützen, und Browsern, die den strikten Modus unterstützen. Das Verhalten ist ebenfalls unterschiedlich, verwenden Sie daher nicht strikt Modus, ohne die Funktionen des strengen Modus zu testen. Der strenge Modus kann mit dem nicht strengen Modus koexistieren, sodass Skripte den strengen Modus schrittweise und selektiv hinzufügen können

• Der Zweck des strengen Modus

Erstens wandelt der strikte Modus JavaScript-Fallen direkt in offensichtliche Fehler um. Zweitens korrigiert der strikte Modus einige Fehler, die für Engines schwer zu optimieren sind: Derselbe Code hat einige. Manchmal ist der strikte Modus schneller als der nicht strikte Modus. Drittens deaktiviert der strikte Modus einige Syntaxen, die möglicherweise in zukünftigen Versionen definiert werden.

• Strikten Modus global aktivieren

Um den strikten Modus in JavaScript zu aktivieren , müssen Sie vor dem gesamten Code eine Zeichenfolge definieren, die keiner Variablen zugewiesen wird:

'use strict';//或者"use strict"

Wenn sich das vorherige JavaScript im nicht-strikten Modus befindet, wird empfohlen, den strikten Modus für diesen Code nicht blind zu aktivieren. da dies zu Problemen führen kann, wird empfohlen, den strikten Modus für jede Funktion zu aktivieren.
Sie können den strikten Modus auch für eine bestimmte Funktion aktivieren:

//函数外部依旧是非严格模式
function fun(){
    'user strict';//开启严格模式
}

in Anonymous. Die Verwendung des strikten Modus in einer Funktion entspricht einer Alternative Implementierung der globalen Aktivierung des strikten Modus

(function(){
    'use strict';//开启严格模式
})();

• Verhindern der versehentlichen Erstellung von Variablen

Im strikten Modus ist die versehentliche Erstellung globaler Variablen nicht zulässig
Der folgende Beispielcode ist die versehentliche Erstellung globaler Variablen im nicht strikten Modus

//未声明的变量
result='这是一个没用var声明的全局变量';

Der folgende Beispielcode ist die versehentliche Erstellung globaler Variablen im strikten Modus

'use strict';//开启严格模式
//严格模式下，意外创建全局变量，抛出ReferenceError
message='this is message';//ReferenceError: result is not defined

• Stiller Fehler wird in eine Ausnahme umgewandelt

Stiller Fehler bedeutet, dass er weder einen Fehler meldet noch irgendeine Auswirkung hat, wie z. B. die Änderung des Werts einer Konstante. Im strikten Modus stiller Fehler wird in das Auslösen einer Ausnahme umgewandelt. Hinweis: Dies ist in Browser unterteilt, einige Browser werden es tun und andere nicht.
Der folgende Code ist ein stiller Fehler im nicht strengen Modus.

const PI=3.14;
PI=1.14;//静默失败
console.log(PI);//3.14

Der folgende Code ist ein stiller Fehler im strikten Modus

'use strict';//开启严格模式

const PI=3.14;
PI=1.14;//抛出TypeError错误

• Löschschlüsselwort deaktivieren

Im strikten Modus kann der Löschoperator nicht für Variablen verwendet werden
The Der folgende Code verwendet den Löschoperator im nicht strengen Modus. Das Ergebnis schlägt stillschweigend fehl

Einschränkungen für Variablennamen

• Im strikten Modus gelten in JavaScript auch Einschränkungen für Variablennamen. Insbesondere können Sie keine Implementierungen, Schnittstellen, Let, Package, Private usw. verwenden. protected, public, static und yield als Variablennamen sind alle reservierte Wörter. Sie können in der nächsten Version von ECMAScript verwendet werden. Im strikten Modus führt die Verwendung dieser Bezeichner als Variablennamen zu Syntaxfehlern

Nicht löschbare Attribute

• Im strikten Modus kann der Löschoperator nicht zum Löschen nicht löschbarer Attribute verwendet werden

  Das folgende Codebeispiel verwendet den Löschoperator zum Löschen nicht löschbarer Attribute in nicht -strikter Modus, und das Ergebnis ist ein stiller Fehler

var color='red';
delete color;

Der folgende Beispielcode verwendet den Löschoperator, um ein nicht löschbares Attribut im strikten Modus zu löschen. Das Ergebnis ist eine Ausnahme

'use strict';//开启严格模式

var color='red';
delete color;//SyntaxError: Delete of an unqualified identifier in strict mode.

Der Attributname muss eindeutig sein

• Im strikten Modus müssen alle Attributnamen eines Objekts innerhalb des Objekts eindeutig sein

  Der folgende Beispielcode zeigt, dass dies bei duplizierten Attributen der Fall ist Im nicht strikten Modus zulässig. Das letzte Attribut mit demselben Namen bestimmt seinen Attributwert.

delete Object.prototype;

Das folgende Codebeispiel ist ein Syntaxfehler für Attribute mit doppelten Namen im strikten Modus 🎜>

Zuweisung von schreibgeschützten Attributen

Im strikten Modus kann ein schreibgeschütztes Attribut nicht neu zugewiesen werden

Der folgende Code ist im nicht strikten Modus, um ein neu zuzuweisen schreibgeschütztes Attribut, und das Ergebnis wird ein stiller Fehler sein

• 'use strict';//开启严格模式
  delete Object.prototype;//TypeError: Cannot delete property 'prototype' of function Object() { [native code] }

  Der folgende Code befindet sich im strikten Modus. Das schreibgeschützte Attribut wird unten neu zugewiesen, und das Ergebnis wird eine Ausnahme sein

  var o={p:1,p:2};

Nicht erweiterbares Objekt

Im strikten Modus kann es nicht nicht erweiterbar sein. Das erweiterte Objekt fügt neue Eigenschaften hinzu

Der folgende Code dient zum Hinzufügen neuer Eigenschaften Nicht erweiterbare Objekte im nicht strikten Modus, und das Ergebnis ist ein stiller Fehler

• 'use strict';//开启严格模式
  var o={p:1,p:2};//不报错但是语法错误

  Der folgende Code dient zum Hinzufügen neuer Eigenschaften zu nicht erweiterbaren Objekten im strikten Modus. Das Ergebnis wird eine Ausnahme auslösen

  var obj={};
  Object.defineProperty(obj,'name',{
      value:'张三',
      writable:false
  });//将属性设置为只读
  obj.name='李四';

Der Parametername muss eindeutig sein

Im strikten Modus müssen die Parameter der benannten Funktion eindeutig sein

Der Beispielcode lautet: Der letzte Parameter mit demselben Namen im nicht strengen Modus überdeckt die vorherigen Parameter mit demselben Namen. Auf die vorherigen Parameter kann weiterhin über arguments[i] zugegriffen werden.

• 'use strict';//开启严格模式
  var obj={};
  Object.defineProperty(obj,'name',{
      value:'张三',
      writable:false
  });//将属性设置为只读
  obj.name='李四';//TypeError: Cannot assign to read only property 'name' of object '#a87fdacec66f0909fc0757c19f2d2b1d'

  Der folgende Beispielcode ist der Parameter mit Gleicher Name im strengen Modus. Denke, es handelt sich um einen Grammatikfehler.

  var obj={};
  Object.preventExtensinons(obj);//将对象设置为不可扩展
  obj.name='张三';

Unterschied in den Argumenten

在严格模式下，arguments对象的行为也有所不同
1.非严格模式下，修改命名参数的值也会反应到arguments对象中
2.严格模式下，命名参数与arguments对象是完全独立的

function fun(value){
    value='haha';
    console.log(value);//haha
    console.log(arguments[0]);//非严格模式下 hah
                              //严格模式下 hello
}

showValue('hello');
``

 - arguments.callee()
在严格模式下，不能使用arguments对象的callee()方法
下例代码是非严格模式下使用arguments对象的callee()方法，表示调用函数本身

var f=function(){
return arguments.callee;
};
f();

下例代码是严格模式下使用arguments对象的callee()方法，结果会抛出异常

'use strict';//开启严格模式
var f=function(){
return arguments.callee;
}
f();
/TypeError: 'caller', 'callee', and 'arguments' properties 
may not be accessed on strict mode functions or the arguments objects 
for calls to them/

 - 函数声明的限制
在严格模式下，只能在全局域和函数域中声明函数
下例代码非严格模式下在任何位置声明函数都是合法的

if(true){
function f(){}
}

下例是严格模式下在除全局域和函数域中声明函数是语法错误

'use strict';//开启严格模式
if(true){
function f(){}//语法错误,但是不报错
}

 - 增加eval作用域
在严格模式下，使用eval()函数创建的变量只能在eval()函数内部使用
下例代码是非严格模式下eval()函数创建的变量在其他位置可以使用

eval('var n=40');
console.log(n);//40

下例代码是严格模式下eval()函数创建的变量只能在eval()函数内部使用

'use strict';//开启严格模式
eval('var n=40');
console.log(n);//ReferenceError: n is not defined

 - 禁止读写
在严格模式下，禁止使用eval()和arguments作为标识符，也不允许读写它们的值
1.使用var声明
2.赋予另一个值
3.尝试修改包含的值
4.用作函数名
5.用作命名的函数的参数
6.在try...catch语句中用作例外名
在严格模式下，以下所有尝试将导致语法错误：

'use strict';//开启严格模式
eval=17;
arguments++;
++eval;
var obj={set p(arguments){}};
var eval;
try{}catch(arguments){}
function x(eval){}
function argunments(){}
var y=function eval(){}
var f=new Function('arguments','"use strict";return 20;');

 - 抑制this
在非严格模式下使用函数apply()或call()方法时，null或undefined值会被转换为全局对象
在严格模式下，函数的this值始终是指定的值(无论什么值)。

var color='red';
function sayColor(){
console.log(this.color);//非严格模式下 red
                    /*严格模式下：TypeError: Cannot 
                     read property 'color' of null*/
                     }

相关推荐：

JS设计模式之构造器模式详解

怎么使用JS严格模式

Das obige ist der detaillierte Inhalt vonEine kurze Analyse dessen, was Sie über den strikten Modus in js wissen müssen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!