Das Javascript-Tutorial verwendet den strikten Strict-Modus mit ausführlicher Erklärung

Strenger Modus: Der durch die ECMA-262-Spezifikation definierte JavaScript-Standard weist strengere Einschränkungen für Javascript auf. In diesem Artikel wird hauptsächlich die detaillierte Erklärung der Verwendung des strengen Javascript-Modus vorgestellt. Freunde, die es benötigen, können sich auf

Strikter Modus beziehen: Der durch die ECMA-262-Spezifikation definierte JavaScript-Standard unterliegt stärkeren Einschränkungen für Javascript.

(Der nicht-strikte Modus wird als „Sloppy-Modus/Sparse-Modus/Lazy-Modus“ bezeichnet.)

1. Verwendung des strikten Modus

Der strenge Modus kann auf Skript- oder Funktionsebene implementiert werden. (d. h. globaler und lokaler Modus)

1. Global

am Anfang der js-Datei hinzufügen

Lokal

Die Funktion fügt intern „use strict“ hinzu, wie folgt

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

2. Vergleich zwischen striktem Modus und nicht striktem Modus

1. Im strikten Modus können Variablen nicht gelöscht werden (delete ist ein unqualifizierter Bezeichner)). Im nicht strengen Modus gibt ein Löschfehler „false“ zurück.

"use strict";
var x;
delete x;//报错Delete of an unqualified identifier in strict mode.（不合格的标识符）

2 Im strikten Modus wird ein Fehler ausgegeben, wenn der Funktionsparameter denselben Namen hat. Nicht-strikter Modus wird nicht

Im strikten Modus

function fn(a,a){
 "use strict";
  result=a+a;
  console.log(result);
}
fn(2,4);//Duplicate parameter name not allowed in this context(重复的参数名称在此上下文中不允许)

Im nicht-strikten Modus

function fn1(a,a){
  "use strict";
  result=a+a;
  console.log(result);
}
fn1(2,4);//结果为8

3. Der strikte Modus erlaubt keine oktalen Ganzzahlliterale (unten). Im nicht strikten Modus wird kein Fehler gemeldet.

"use strict"
var x=089;
console.log(x);//报错：Decimals with leading zeros are not allowed in strict mode.

4. Im strikten Modus ist das Argumentobjekt eine statische Kopie der tatsächlichen Parameterliste, die an die Funktion übergeben wird (d. h. Parameteränderungen werden nicht mehr verfolgt). ); nicht-strikter Modus Im Folgenden sind die Elemente im Argumentobjekt und die entsprechenden tatsächlichen Parameter Verweise auf denselben Wert.

Im strengen Modus

fn(5);
function fn(a){
  "use strict";
  a = 42;
  // return a==arguments[0];//返回false
  console.log(a);//结果为42
  console.log(arguments[0]);//结果为5,严格模式下arguments[0]表示这个调用方法的第一个参数     (不再追踪  参数的变化，在函数内部，参数a被重新赋值为42，但arguments[0]仍然为5.)
}

Im nicht strengen Modus

fn(5);
function fn(a){
  a = 42;
  // return a==arguments[0];//返回true
  console.log(a);//结果为42
  console.log(arguments[0]);//结果为42(追踪参数变化)

}

5. Im strikten Modus werden Auswertung und Argumente als Schlüsselwörter verwendet. Sie können nicht zugewiesen und als Variablendeklarationen verwendet werden Erkennen Sie den Aufrufstapel, greifen Sie auf arguments.callee zu und arguments.callee.caller löst eine Ausnahme aus

Im strikten Modus:

"use strict";
var eval=3;//报错：Unexpected eval or arguments in strict mode
var argument=6；//同样报错

Im Nicht- Strikter Modus:

"use strict";
function fn(n){
  if(n==0){
    return 1;
  }else{
    return n*arguments.callee(n-1);
  }
}
console.log(fn(5));//报错

Aufrufer: Wenn eine Funktion eine andere Funktion aufruft, generiert die aufgerufene Funktion automatisch ein Aufruferattribut, das auf das Funktionsobjekt verweist, das sie aufgerufen hat. Wenn die Funktion derzeit nicht aufgerufen wird oder nicht von anderen Funktionen aufgerufen wird,

, dann ist der Aufrufer null. Wie folgt:

Im strengen Modus:

function fn(n){//阶乘
  if(n==0){
    return 1;
  }else{
    return n*arguments.callee(n-1);
  }
}
console.log(fn(5));//正常120

Im nicht strengen Modus:

"use strict"
function fn1() {
  var n1= fn1.caller;
  console.log(n1);
}
function fn2() {
  fn1();
}
fn2();//报错

7. Strikte Modusvariablen müssen zuerst deklariert und der Variablen direkt zugewiesen werden. Globale Variablen werden nicht implizit erstellt und können nicht verwendet werden.

Im strikten Modus

function fn1() {
  var n1= fn1.caller;//此例中caller指向调用它的函数（fn2）
  console.log(n1);
}
function fn2() {
  fn1();
}
fn2();// 结果打印出：function fn2(){ fn1( ) };

Erklärung: Beim Ausführen eines Skripts wird es zuerst kompiliert und dann ausgeführt. Offensichtlich kann zur Kompilierungszeit nicht bestimmt werden, zu welchem ​​Objekt die Variablen im with-Anweisungsblock gehören. [Die Variablen im with-Anweisungsblock sind Attribute

von (cl) oder Variablen in der Variablenbereichskette der oberen Ebene. ]. Es kann nur zum Zeitpunkt der Ausführung festgestellt werden, dass (c1) eine Instanz von Clothes ist. Dies steht im Konflikt mit dem strikten Modus, der prüft, ob Variablen zur Kompilierungszeit definiert sind, sodass der strikte Modus die with-Anweisung nicht verwendet.

Erweiterung: Verwendung der with-Anweisung (wird verwendet, um auf vorhandene Attribute in einem bestimmten Objekt zu verweisen, kann aber nicht zum Hinzufügen von Attributen zum Objekt verwendet werden.)

"use strict"；
with（obj）{
  x；
}//报错：Strict mode code may not include a with statement

Im strikten Modus bleibt null undefiniert, das an den Aufruf „apply“ übergeben wird, unverändert und wird nicht in „window“ konvertiert

Das obige ist der detaillierte Inhalt vonDas Javascript-Tutorial verwendet den strikten Strict-Modus mit ausführlicher Erklärung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!