Une brève analyse de ce que vous devez savoir sur le mode strict en js

Le contenu de cet article concerne une brève analyse du contenu requis pour maîtriser le mode strict en js. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Mode strict

Tout d'abord, comprenons ce qu'est le mode strict ?
Le mode strict est une variante plus restrictive de JavaScript, pas un sous-ensemble : il est sémantiquement différent du code normal, des navigateurs qui ne prennent pas en charge le mode strict et des navigateurs qui prennent en charge le mode strict. Le comportement est également différent, donc n'utilisez pas strict mode sans tester les fonctionnalités du mode strict. Le mode strict peut coexister avec le mode non strict, de sorte que les scripts peuvent ajouter progressivement et sélectivement le mode strict

• Le but du mode strict

Tout d'abord, le mode strict transformera directement les pièges JavaScript en erreurs évidentes. Deuxièmement, le mode strict corrige certaines erreurs difficiles à optimiser pour les moteurs : le même code en comporte. Parfois, le mode strict sera plus rapide que le non strict. mode. Troisièmement, le mode strict désactive certaines syntaxes qui pourraient être définies dans les versions futures

• Activer le mode strict globalement

Pour activer le mode strict en JavaScript. , vous devez définir une chaîne qui ne sera assignée à aucune variable avant tout le code :

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

Si le JavaScript précédent est en mode non strict Si c'est le cas, il est recommandé de ne pas activer aveuglément le mode strict pour ce code, car cela peut poser des problèmes. Il est recommandé d'activer le mode strict pour chaque fonction
Vous pouvez également activer le mode strict pour une fonction spécifiée :

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

Utiliser le mode strict dans les fonctions anonymes est équivalent à une implémentation flexible de l'activation du mode strict globalement

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

• La création accidentelle de variables est interdite

En mode strict, création accidentelle des variables globales n'est pas autorisé
L'exemple de code suivant est la création accidentelle de variables globales en mode non strict

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

L'exemple de code suivant est la création accidentelle de variables globales en mode strict

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

• L'échec silencieux est converti en exception

L'échec silencieux signifie ne pas signaler d'erreur ni avoir d'effet, comme changer la valeur de un échec silencieux constant, en mode strict, sera converti en émission d'une exception. Remarque : ceci est divisé en navigateurs, certains navigateurs le feront et d'autres non
L'exemple de code suivant est un échec silencieux en mode non strict<.>

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

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

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

• Désactiver le mot-clé de suppression

Le code suivant utilise l'opérateur delete en mode non strict, et le résultat échouera silencieusement

var color='red';
delete color;

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

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

• Restrictions sur les noms de variables

• Attributs non supprimables

L'exemple de code suivant n'est pas L'utilisation de l'opérateur de suppression en mode strict pour supprimer des attributs non supprimables entraînera un échec silencieux

delete Object.prototype;

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

• Les noms d'attribut doivent être uniques

L'exemple suivant Le code est en mode non strict et les attributs avec des noms en double sont autorisés Le dernier attribut portant le même nom détermine sa valeur d'attribut

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

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

Affectation d'attributs en lecture seule
En mode strict, un attribut en lecture seule ne peut pas être réaffecté

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

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

Objets non extensibles
En mode strict, de nouvelles propriétés ne peuvent pas être ajoutées aux objets non extensibles

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

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

var obj={};
Object.preventExtensions(obj);//将对象变得不可扩展
obj.name='张三';//TypeError: Cannot add property name, object is not extensible

Les noms des paramètres doivent être uniques
En mode strict, les paramètres des fonctions nommées doivent être uniques

function sum(a,a,c){}

function sum(a,a,c){//语法错误
    'use strict';
    return a+a+c;//代码运行到这里会出错：SyntaxError: Duplicate parameter name not allowed in this context
}

Différences d'arguments

在严格模式下，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严格模式

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!