Qu'est-ce que le mode strict en javascript

Le mode strict JavaScript fait référence à l'exécution de code dans des conditions strictes. Ce mode définit un modèle d'analyse et d'exécution différent pour JavaScript. Il vérifiera les erreurs de code des développeurs dans des conditions plus strictes et peut également être utilisé localement (appliqué). à l'intérieur d'une fonction).

L'environnement d'exploitation de ce tutoriel : système Windows 7, JavaScript version 1.8.5, ordinateur Dell G3.

1. Qu'est-ce que le mode strict

Dans ES5, JS a introduit pour la première fois le concept de mode strict. Le mode strict JavaScript s'exécute dans des conditions strictes.

Le mode strict définit un modèle d'analyse et d'exécution différent pour JavaScript. Il vérifiera vos erreurs de code dans des conditions plus strictes. Il peut être utilisé globalement ou localement (appliqué dans une fonction). Il est très nécessaire de comprendre les règles du mode strict. À l'avenir, ECMAScript forcera progressivement l'utilisation du mode strict à l'échelle mondiale.

Comme son nom l'indique, ce mode permet à Javascript de s'exécuter dans des conditions plus strictes.

Les principaux objectifs de l'établissement du « mode strict » sont les suivants :

　 - Éliminer certains aspects déraisonnables et imprécis de la syntaxe Javascript et réduire certains comportements étranges

　 - Éliminer certains aspects dangereux de l'exécution du code, assurer la sécurité du code ; en cours d'exécution ;

　 - Améliorer l'efficacité du compilateur et augmenter la vitesse d'exécution

　 - Ouvrir la voie à de nouvelles versions de Javascript à l'avenir ;

Le « mode strict » incarne l'orientation de développement plus raisonnable, plus sûre et plus rigoureuse de Javascript. Les navigateurs grand public, y compris IE 10, le prennent déjà en charge, et de nombreux grands projets ont commencé à l'adopter pleinement.

D'un autre côté, le même code peut avoir des résultats d'exécution différents en « mode strict » ; certaines instructions qui peuvent être exécutées en « mode normal » ne s'exécuteront pas en « mode strict ». La maîtrise de ces contenus vous aidera à comprendre Javascript plus en détail et fera de vous un meilleur programmeur.

Cet article présentera le « mode strict » en détail.

2. Drapeau d'entrée

Le signe pour entrer en "mode strict" est la ligne d'instruction suivante :

　　"use strict";

Les anciennes versions des navigateurs le traiteront comme une ligne de chaînes ordinaires et l'ignoreront.

3. Comment appeler

Le "mode strict" propose deux méthodes d'appel, adaptées à différentes occasions.

3.1 Pour l'intégralité du fichier de script

Mettez "use strict" dans la première ligne du fichier de script, puis l'ensemble du script s'exécutera en "mode strict". Si cette ligne d'instruction n'est pas la première ligne, elle n'a aucun effet et l'ensemble du script s'exécute en « mode normal ». Cela nécessite une attention particulière si des fichiers de code de différents modes sont fusionnés en un seul fichier.

(À proprement parler, tant que l'instruction précédente n'est pas une instruction qui produit des résultats d'exploitation réels, "use strict" n'a pas besoin d'être sur la première ligne, par exemple directement après un point-virgule vide.)

　　<script>
　　　　&quot;use strict&quot;;
　　　　console.log("这是严格模式。");
　　</script>
　　<script>
　　　　console.log("这是正常模式。");kly, it&#39;s almost 2 years ago now. I can admit it now - I run it on my school&#39;s network that has about 50 computers.
　　</script>

Ce qui précède Le code indique que dans une page Web, il y a deux morceaux de code Javascript en séquence. La première balise de script est en mode strict, mais la seconde ne l'est pas.

3.2 Pour une seule fonction

mettez "use strict" dans la première ligne du corps de la fonction, puis la fonction entière s'exécutera en "mode strict".

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

3.3 Manière alternative d'écrire des fichiers de script

Étant donné que la première méthode d'appel n'est pas propice à la fusion de fichiers, une meilleure approche consiste à emprunter la deuxième méthode et à placer l'intégralité du fichier de script dans une fonction anonyme qui est exécutée immédiatement au milieu. .

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

4. Modifications de syntaxe et de comportement

Le mode strict a apporté quelques modifications à la syntaxe et au comportement de Javascript.

4.1 Déclaration explicite des variables globales

En mode normal, si une variable se voit attribuer une valeur sans être déclarée, elle est par défaut une variable globale. Le mode strict interdit cette utilisation et les variables globales doivent être déclarées explicitement.

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

Par conséquent, en mode strict, les variables doivent être déclarées avec la commande var avant utilisation.

4.2 Liaison statique

Une caractéristique du langage Javascript est qu'il permet une "liaison dynamique", c'est-à-dire que l'objet auquel appartiennent certaines propriétés et méthodes n'est pas déterminé au moment de la compilation, mais au moment de l'exécution.

Le mode strict impose certaines restrictions sur la liaison dynamique. Dans certains cas, seule la liaison statique est autorisée. En d’autres termes, l’objet auquel appartiennent les propriétés et les méthodes est déterminé lors de la phase de compilation. Cela contribuera à améliorer l’efficacité de la compilation, à rendre le code plus facile à lire et à provoquer moins de surprises.

Plus précisément, cela implique les aspects suivants.

(1) Il est interdit d'utiliser l'instruction with

car l'instruction with ne peut pas déterminer au moment de la compilation à quel objet appartient l'attribut.

　　"use strict";
　　var v = 1;
　　with (o){ // 语法错误
　　　　v = 2;
　　}

(2) Créer une portée d'évaluation

En mode normal, le langage Javascript a deux portées variables : la portée globale et la portée de la fonction. Le mode strict crée une troisième portée : la portée d'évaluation.

正常模式下，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），以及各大浏览器自行增加的const保留字，也是不能作为变量名的。

【相关推荐：javascript学习教程】

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!