Le tutoriel Javascript utilise une explication détaillée du mode strict strict

Mode strict : la norme JavaScript définie par la spécification ECMA-262 a des restrictions plus strictes sur javascript. Cet article présente principalement l'explication détaillée de l'utilisation du mode strict Javascript. Les amis qui en ont besoin peuvent se référer à

Mode strict : la norme JavaScript définie par la spécification ECMA-262 a des restrictions plus strictes sur javascript.

(Le mode non strict est appelé "mode bâclé/mode clairsemé/mode paresseux".)

Utilisation du mode strict

Le mode strict peut être implémenté au niveau du script ou de la fonction. (c'est-à-dire les modes global et local)

1. Global

ajoutez "use strict" au début du fichier js

2. la fonction Ajouter "use strict" en interne, comme suit

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

2. Comparaison entre le mode strict et le mode non strict1. En mode strict, les variables ne peuvent pas être supprimées (la suppression est un identifiant non qualifié)). En mode non strict, l'échec de la suppression renverra false

2 En mode strict, si le paramètre de fonction a le même nom, une erreur sera générée ; le mode non strict ne le fera pas

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

En mode strict

En mode non strict

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

3. Le mode strict n'autorise pas les littéraux entiers octaux (ci-dessous). Aucune erreur ne sera signalée en mode non strict.

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

4. En mode strict, l'objet arguments est une copie statique de la liste de paramètres réelle dans la fonction transmise (c'est-à-dire que les modifications de paramètres ne sont plus tracked); mode non strict Ci-dessous, les éléments de l'objet arguments et les paramètres réels correspondants sont des références à la même valeur.

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

En mode strict

En mode non strict

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.)
}

5. En mode strict, eval et arguments sont utilisés comme mots-clés, ils ne peuvent pas être attribués et utilisés comme déclarations de variables

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

}

6. Le mode strict limitera la possibilité de le faire. détecte la pile d'appels, en accédant à arguments.callee, arguments.callee.caller lèvera une exception

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

En mode strict :

En mode non- mode strict :

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

caller : Lorsqu'une fonction appelle une autre fonction, la fonction appelée générera automatiquement un attribut caller pointant vers l'objet fonction qui l'a appelée. Si la fonction n'est pas actuellement appelée ou n'est pas appelée par d'autres fonctions,

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

alors l'appelant est nul. Comme suit :

En mode strict :

En mode non strict :

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

7. Les variables en mode strict doivent être déclarées en premier et affectées directement à la variable. Les variables globales ne seront pas créées implicitement et ne peuvent pas être utilisées.

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

En mode strict

Explication : Lors de l'exécution d'un script, il est d'abord compilé puis exécuté. Évidemment, au moment de la compilation, il ne peut pas être déterminé à quel objet appartiennent les variables du bloc d'instruction with. [Les variables du bloc d'instruction with sont des attributs

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

de (cl) ou des variables dans la chaîne de portée des variables de niveau supérieur. ]. Il ne peut être déterminé qu'au moment de l'exécution que (c1) est une instance de Clothes. Cela entre en conflit avec le mode strict, qui vérifie si les variables sont définies au moment de la compilation, donc le mode strict n'utilise pas l'instruction with.

Extension : utilisation de l'instruction with (utilisée pour référencer des attributs existants dans un objet spécifique, mais ne peut pas être utilisée pour ajouter des attributs à l'objet.)

En mode strict, null undefined transmis à call apply reste tel quel et n'est pas converti en window

with(object instance)
{
  //代码块
}
eg：function Clothes(){
  this.color="red";
  this.size="m";
  this.price="cheap";
}
var c1=new Clothes();
with(c1){
  var str="颜色："+color+"，尺寸："+size+"，价格："+price;
  document.write(str);
}//结果(颜色：red，尺寸：m，价格：cheap)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!