Home > Article > Web Front-end > A direct look at Javascript’s strict mode (“use strict”)
Javascript strict mode ("use strict") detailed explanation
Share:
Except normal Running mode, ECMAscript 5 adds a second running mode: "strict mode". As the name suggests, this mode makes Javascript run under stricter conditions.
The purpose of establishing "strict mode" is mainly as follows:
- 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;
- Prepare for future new versions of Javascript Make good preparations.
"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 begun to fully embrace it. it.
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.
This article will introduce "strict mode" in detail.
2. Entry flag
The flag to enter "strict mode" is the following line:
"use strict";
Older versions of browsers will treat it as a line of ordinary characters String, ignore it.
3. How to call
There are two calling methods for "strict mode", which are suitable for different occasions.
3.1 For the entire script file
Put "use strict" on the first line of the script file, and the entire script will run in "strict mode". If this line of statement is not the first line, it is invalid and the entire script runs in "normal mode". This needs special attention if code files from different modes are merged into one file.
(Strictly speaking, as long as it is not preceded by a statement that produces actual operating results, "use strict" does not need to be on the first line, such as directly following an empty semicolon.)
<script>
"use strict";
console.log("这是严格模式。");
</script>
<script>
console.log("这是正常模式。");kly, it's almost 2 years ago now. I can admit it now - I run it on my school's network that has about 50 computers.
</script>The above code indicates that there are two pieces of Javascript code in a web page. The former script tag is in strict mode, but the latter one is not.
3.2 For a single function
Put "use strict" on the first line of the function body, and the entire function will run in "strict mode".
function strict(){
"use strict";
return "这是严格模式。";
}
function notStrict() {
return "这是正常模式。";
}3.3 Alternative way of writing script files
Because the first calling method is not conducive to file merging, a better approach is to borrow the second method and put the entire script file in one within an anonymous function that is executed immediately.
(function (){
"use strict";
// some code here
})();4. Syntax and behavior changes
Strict mode has made some changes to the syntax and behavior of Javascript.
4.1 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.
4.2 Static Binding
One feature of the Javascript language is that it allows "dynamic binding", that is, which object certain properties and methods belong to is not determined at compile time, but It is determined at runtime.
Strict mode places some restrictions on dynamic binding. In some cases, only static binding is allowed. In other words, which object the properties and methods belong to is determined during the compilation stage. This will help improve compilation efficiency, make the code easier to read, and cause fewer surprises.
Specifically, it involves the following aspects.
(1) It is forbidden to use the with statement
Because the with statement cannot determine at compile time which object the attribute belongs to.
"use strict";
var v = 1;
with (o){ // 语法错误
v = 2;
}(2) Create eval scope
In normal mode, the Javascript language has two variable scopes (scope): global scope and function scope. Strict mode creates a third scope: eval scope.
In normal mode, the scope of the eval statement depends on whether it is in the global scope or the function scope. In strict mode, the eval statement itself is a scope and can no longer generate global variables. The variables it generates can only be used inside eval.
"use strict";
var x = 2;
console.info(eval("var x = 5; x")); // 5
console.info(x); // 24.3 Enhanced security measures
(1) Prohibit the this keyword 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 not Then point to the global object, but an error is reported.
function f(){
"use strict";
this.a = 1;
};
f();// 报错，this未定义(2) It is forbidden to traverse the call stack inside the function
function f1(){
"use strict";
f1.caller; // 报错
f1.arguments; // 报错
}
f1();4.4 It is forbidden to delete variables
Variables cannot be deleted in strict mode. Only object properties 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; // 删除成功4.5 Explicit error reporting
In normal mode, assigning a value to the read-only property of an object will not report an error, but will only fail silently. In strict mode, an error will be reported.
"use strict";
var o = {};
Object.defineProperty(o, "v", { value: 1, writable: false });
o.v = 2; // 报错In strict mode, an error will be reported when assigning a value to an attribute read using the getter method.
"use strict";
var o = {
get v() { return 1; }
};
o.v = 2; // 报错In strict mode, adding new attributes to objects that are prohibited from expansion will result in an error.
"use strict";
var o = {};
Object.preventExtensions(o);
o.v = 1; // 报错In strict mode, deleting an attribute that cannot be deleted will result in an error.
"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保留字，也是不能作为变量名的。
推荐教程：《js基础教程》
The above is the detailed content of A direct look at Javascript’s strict mode (“use strict”). For more information, please follow other related articles on the PHP Chinese website!