JavaScript 严格模式 "use strict"

最新推荐文章于 2024-02-06 07:45:00 发布

原创最新推荐文章于 2024-02-06 07:45:00 发布 · 475 阅读

1 ·

CC 4.0 BY-SA版权

JavaScript 专栏收录该内容

34 篇文章

订阅专栏

本文详细解析了ECMAScript5的严格模式，介绍了其启动方式、执行限制及对JavaScript语法和行为的影响，如变量声明、静态绑定、安全措施等。

1、启用严格模式

2、严格模式的执行限制

ECMAscript5新增严格运行模式，顾名思义，严格模式就是使 Javascript 在更严格的条件下运行。包括 IE10 在内的主流浏览器都已经支持它，许多大项目已经开始全面拥抱它。定义严格模式的目的：

消除 Javascript 语法的一些不合理、不严谨之处，减少一些怪异行为。

消除代码运行的一些不安全之处，保证代码运行的安全。

提高编译器效率，增加运行速度。

为未来新版本的 Javascript 做好铺垫。

1、启用严格模式

启用严格模式很简单，只要在代码首部加入如下注释字符串即可：

"use strict"

不支持该模式的浏览器会把它当作一行普通字符串，加以忽略。严格模式有两种应用场景，一种是全局模式，一种是局部模式。

（1）全局模式

将 "use strict" 放在脚本文件的第一行，则整个脚本都将以严格模式运行。如果这行语句不在第一行，则无效，整个脚本将以正常模式运行。如果不同模式的代码文件合并成一个文件，这一点需要特别注意。严格地说，只要前面不是产生实际运行结果的语句，"use strict" 可以不在第一行。

以下代码表示，一个网页中依次有两段 Javascript 代码。前一个 script 标签是严格模式。后一个不是。

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

（2）局部模式

将 "use strict" 放到函数内的第一行，则整个函数将以严格模式运行。

function(){
    "use strict";    
    console.log("这是严格模式。");
}
function(){ 
    console.log("这是正常模式。");
}

（3）模块模式

因为全局模式不利于文件合并，所以更好的做法是，借用局部模式的方法，将整个脚本文件放在一个立即执行的匿名函数之中。如果定义一个模块或者一个库，可以采用一个匿名函数自执行的方式进行设计：

(function(){
    "use strict";
    //在这里编写JavaScript代码
)();

"use strict" 的位置比较讲究，它必须在首部。首部是指其前面没有任何有效 Javascript 代码（可以有注释）。

2、严格模式的执行限制

严格模式是限制性更强的 JavaScript 变体，旨在改善错误检查功能，并且标识可能不会延续到未来 JavaScript 版本的脚本。与常规的 JavaScript 语义不同，其分析更为严格，下面介绍严格模式对 Javascrit 语法和行为限制性规定。

（1）显式声明变量

Javascript 是弱类型语言，不使用 var 声明的变量默认会转为全局变量。但在严格模式中将不允许，会报语法错误。

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

因此，严格模式下，变量都必须先用var命令声明，然后再使用。

（2）静态绑定

在正常模式下，Javascript 允许动态绑定，即某些属性和方法到底属于哪一个对象，不是在编译时确定的，而是在运行时确定的。严格模式对动态绑定做了一些限制。某些情况下，只允许静态绑定。也就是说，属性和方法到底归属哪个对象，在编译阶段就确定。这样限制有利于编译效率的提高，使得代码更容易阅读，避免出现意外。具体来说，涉及以下几个方面。

//（1）禁止使用 with 语句
//因为with语句无法在编译时就确定，属性到底归属哪个对象。例如：
"use strict";
var v = 1;
with (o){        //语法错误
    v=2;
}

//（2）创设eval作用域。
//在正常模式下，Javascript有两种变量作用域：全局作用域和函数作用域。严格模式创设了第三种作用域：eval作用域。
//在正常模式下，eval语句的作用域，取决于它处于全局作用域，还是处于函数作用域。
//而在严格模式下，eval语句本身就是一个作用域，不再能够生成全局变量了，它所生成的变量只能用于eval内部。

"use strict";
var x = 2;
console.info (eval("varx=5;x"));    //5
console.info(x);                    //2

//另外，任何使用eval的操作都会被禁止，例如，以下用法都是非法的。
"use strict";
var obj={}
var eval = 3
obj.eval = 1
obj.a = eval
for(var eval in obj){}
function eval(){}
function func(eval){}
var func = new Function('eval')

（3）增强的安全措施

禁止 this 关键字指向全局对象。执行以下代码，比较正常模式和严格模式下 this 的值。

function fun(){
    return !this;
}//返回false，因为 "this" 指向全局对象,"!this" 就是 false

function fun(){
    "use strict";
    return !this;
}//返回true，因为在严格模式下，this 的值为 undefined，所以"!this" 为 true。

使用构造函数时，如果忘了加 new 语句，this 不再指向全局对象，而是报错。

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

禁止在函数内部遍历调用栈。caller、callee 和 arguments 的调用行为都被禁用。

function fun(){
   "use strict";
    t1.caller;       //报错
    f1.arguments;    //报错
}
fun();

（4）禁止删除变量

在严格模式下无法删除变量。只有 configurable 设置为 true 的对象属性，才能被删除。

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

（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 = 1;
Object.preventExtensions(o);
o.v = 1;    //报错

严格模式下，删除一个不可删除的属性，会报错。

"use strict";
delete Object.prototype;    //报错

（6）重名错误

严格模式新增了一些语法错误。对象不能有重名的属性。在正常模式下，如果对象有多个重名属性，最后赋值的那个属性会覆盖前面的值。在严格模式下，属于语法错误。例如：

"use strict";
var o = {
    p：1,
    p：2
}

函数不能有重名的参数。在正常模式下，如果函数有多个重名的参数，可以用 arguments 读取。在严格模式下，这属于语法错误。例如：

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

（7）禁止八进制表示法

在正常模式下，整数的第一位如果是 0，表示这是八进制数，如 0100 等于十进制的 64。在严格模式中将禁止这种表示法，整数第一位为 0，将报错。例如：

"use strict";
var n = 0100;    //语法错误

（8）arguments对象的限制

arguments 是函数的参数对象，严格模式对它的使用进行限制。不允许对arguments赋值。

"use strict";
arquments++;    //语法错误
var obj = (set p(arguments){ };    //语法错误
try {} catch (arguments){ }        //语法错误
function arguments(){ }            //语法错误
var fun =  new Function("arguments","'use strict';return 17;"）;//语法错误

arguments不再追踪参数的变化。

function fun(a){
    a = 2;
    return [a,arguments[0]];
}
fun();            //正常模式为[2,2]

function fun(a){
    "use strict";
    a = 2;
    return [a,arguments[0]];
}
fun();            //严格模式为[2,1]

禁止使用arguments.callee。这意味着，无法在匿名函数内部调用自身了。例如：

"use strict";
var fun = function(){ return arguments.callee};
fun();    //报错

（9）函数必须声明在顶层

将来 Javascript 的新版本会引入块级作用域。为了与新版本接轨，严格模式只允许在全局作用域或函数作用域的顶层声明函数。也就是说，不允许在非函数的代码块内声明函数。

"use strict"；
if(true){
    function fun(){}    //语法错误
}
for(var i=0;i< 5;i++){
    function fun2(){}    //语法错误
}

（10）保留字

为了向未来 Javascript 新版本过渡，严格模式新增了一些保留字：implements、interface、let、package、private、protected、public、static、yield。使用这些词作为变量名将会报错。

function package(protected){    //语法错误
    "use stxict";
    var implements;        //语法错误
}

此外，ECMAscript 5 本身还规定了另一些保留字，如class、enum、export、extends、import、super，以及各大浏览器自行增加的 const 保留字，这些都是不能作为变量名的。

（11）动态绑定

call、apply 的第一个参数直接传入，不包装为对象。在以下代码中，输出依次为“string”、“number”。而在非严格模式中call、apply 将对值类型的“abcd”包装为对象后传入，即两次输出都为“object”。

'use strict'
function func(){
    console. log(typeof this)
}
func.call('abcd')    //string
func.apply(1)        //number

call、apply 的第一个参数为 null、undefined 时，this 为 null、undefined。以下代码输出依次是undefined、null，而在正常模式中则是宿主对象（浏览器里是window，node.js环境则是global）。

'use strict'
function func(){
    console.1og(this)
}
func.call(undefined)    //undefined 
func.call(null)         //nul1

bind 的第一个参数为 null、undefined 时，this 为 null / undefined。bind 是 ECMAScript 5 给 Function.prototype 新增的一个方法，它和 call、apply 一样在 function 上直接调用。它返回一个指定了上下文和参数的函数。当它的第一个参数为 null、undefined 时，情形和 call、apply 一样，this 也为 null、undefined。

以下代码在非严格模式中输出都是window（或global）

'use strict'
function func(){
    console.1og(this)
}
var funl = func.bind(null)
var fun2 = func.bind(undefined)
fun1();    //null
fun2();    //undefined