Detailed explanation of 'use strict' strict mode in JavaScript

In addition to the normal running mode, ECMAscript 5 adds a second running mode: "strict mode". As the name suggests, this mode makes Javascript run under stricter conditions.

Why use strict mode

• Eliminate some unreasonable and imprecise aspects of Javascript syntax and reduce some weird behaviors;

• Eliminate some insecurities in code running and ensure the safety of code running;

• Improve compiler efficiency and increase running speed;

• To pave the way for new versions of Javascript in the future.

"Strict mode" reflects the more reasonable, safer and more rigorous development direction of Javascript. Mainstream browsers including IE 10 already support it, and many large projects have Start embracing it fully.

On the other hand, the same code may have different running results in "strict mode"; some statements that can be run in "normal mode" will not be able to be run in "strict mode" run. Mastering these contents will help you understand Javascript in more detail and make you a better programmer.

Enter flag

"use strict";

How to call

For a single script

　<script>　　　　&quot;use strict&quot;;
　　　　console.log("这是严格模式。");
　　</script>

For a single function

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

Syntax and behavior changes

Strict mode has made some changes to the syntax and behavior of Javascript.

Explicit declaration of global variables

In normal mode, if a variable is assigned a value without being declared, the default is a global variable. Strict mode prohibits this usage and global variables must be declared explicitly.

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

Therefore, in strict mode, variables must be declared with the var command before use.

This keyword is prohibited from pointing to the global object

function f(){　　　　return !this;
　　} 
　　// 返回false，因为"this"指向全局对象，"!this"就是false　　function f(){ 　　　　"use strict";
　　　　return !this;
　　} 
　　// 返回true，因为严格模式下，this的值为undefined，所以"!this"为true。

Therefore, when using the constructor, if you forget to add new, this will no longer point to the global object, but an error will be reported.

function f(){　　　　"use strict";
　　　　this.a = 1;
　　};
　　f();// 报错，this未定义

Deletion of variables is prohibited

Variables cannot be deleted in strict mode. Only object attributes with configurable set to true can be deleted.

"use strict";
　　var x;
　　delete x; // 语法错误　　var o = Object.create(null, {'x': {
　　　　　　value: 1,
　　　　　　configurable: true　　}});
　　delete o.x; // 删除成功

Objects cannot have attributes with duplicate names

In normal mode, if an object has multiple attributes with duplicate names, the last assigned attribute will overwrite the previous value. In strict mode, this is a syntax error.

"use strict";
　　var o = {
　　　　p: 1,
　　　　p: 2　　}; // 语法错误

Function cannot have parameters with the same name

In normal mode, if the function has multiple parameters with the same name, you can use arguments[i] to read them. In strict mode, this is a syntax error.

　"use strict";
　　function f(a, a, b) { // 语法错误　　　　return ;
　　}

Related recommendations:

JS strict mode example explanation

Detailed introduction to strict mode in JavaScript

Detailed explanation of JavaScript strict mode_javascript skills

The above is the detailed content of Detailed explanation of 'use strict' strict mode in JavaScript. For more information, please follow other related articles on the PHP Chinese website!