欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

EcmaScript6-块级作用域(blockscope)详细介绍

程序员文章站 2022-03-12 09:49:55
1. EcmaScript 5作用域 EcmaScript5的作用域有全局作用域(global scope)与函数作用域(function scope)两种。 1.1 全局作用...

1. EcmaScript 5作用域

EcmaScript5的作用域有全局作用域(global scope)与函数作用域(function scope)两种。

1.1 全局作用域

在全局作用域中定义的变量,在整个上下文中都是可以访问的。

var msg = 'Hello world';
console.log(msg); // Hello world
function sayHi(){
    console.log(msg);// Hello world
}
sayHi();

上面例子中msg在sayHi()函数内外都可以访问。

在NodeJs中,在js文件中直接使用var关键字声明的变量,将会在模块上声明。

浏览器中,在script标签中直接使用var关键字声明的变量,将定义在全局变量window上,window对象中的属性拥有全局作用域。

在严格模式(strict mode)下,变量在初始化前必须声明,否则会抛出ReferenceError

'use strict';
a = 2;
console.log(a); // Uncaught ReferenceError: a is not defined

在非严格模式下,使用未声明的变量将隐式声明为全局变量,定义在window上

a = 2;
console.log(a); // 2
console.log(a === window.a) // true

1.2 函数作用域

在函数作用域中定义的变量,只能在函数中被访问

function fn(){
    var a = 1;
    console.log(a); // 1
}
console.log(a); // Uncaught ReferenceError: a is not defined

2. 声明提升

声明提升(hoisting)指通过var关键字声明的变量,将提升到函数(或者全局作用域)的顶部进行声明,与声明语句的实际位置无关。

function sayHi(condition){
    if(condition){
        var msg = 'Hello world';
        console.log(msg); // Hello world
    }else{
        console.log(msg); // undefined
    }
}

sayHi(true);
sayHi(false);

上面例子中msg在if语句中进行了声明和初始化赋值,但实际上msg将“提升”到函数顶部进行声明,而赋值的位置不变,还在if语句中。因此在else语句中同样可以访问msg变量,其值为undefined。Javascript引擎会将上面的代码处理成类似下面的样子。

function sayHi(condition){
    var msg;
    if(condition){
        msg = 'Hello world';
        console.log(msg); // Hello world
    }else{
        console.log(msg); // undefined
    }
}

sayHi(true);
sayHi(false);

3. 块级作用域声明

EcmaScript 6引入了块级作用域(block scope),块级作用域只能在块中被访问,以下两种情况可以创建块级作用域的变量。

在函数中

在被{和}包裹的块中

3.1 let声明

let关键字的作用类似var,用来声明变量,不同的是其声明的变量具有块级作用域。

'use strict';
function sayHi(condition){
    if(condition){
        let msg = 'Hello world';
        console.log(msg); // Hello world
    }else{
        console.log(msg); // ReferenceError: msg is not defined
    }
}

sayHi(true);
sayHi(false);

如上面例子,msg只能在if语句块中被访问,在else中访问会产生ReferenceError错误

3.2 不能重复声明

使用var关键字声明的变量,在同一个作用域可以重复进行声明,后面的将会覆盖前面的。而使用let关键字声明的变量,在同一个作用域不能重复声明(不管之前是用var,let, 或者const声明),否则将会触发SyntaxError错误。

'use strict';
var a = 1;
var a = 2;

//var b = 1;
//let b = 2; // SyntaxError: Identifier 'b' has already been declared

//let c = 1; 
//let c = 2; // SyntaxError: Identifier 'c' has already been declared

const d = 1;
let d = 2; // SyntaxError: Identifier 'd' has already been declared

在变量包含的作用域是用let关键字声明的变量,不会生成错误。如下面代码,在if语句中,新的变量a将覆盖外面的变量a。

'use strict';
let a = 1;

if(true){
    let a = 2;
    console.log(a); // 2
}
console.log(a); // 1

3.3 const声明

使用const关键字声明的变量将作为常量使用,一旦被赋值,将不能再被改变,因此const关键字声明的变量必须同时进行初始化,否则会抛出SyntaxError错误

'use strict';
const maxItems = 30;

const name; // SyntaxError: Unexpected token

上面例子中的name变量没有进行初始化,因此将触发SyntaxError。

const关键字与let关键字相同的地方

声明的变量具有块级作用域。在相同的作用域,重复声明变量将会抛出SyntaxError错误

const关键字与let关键字不同的地方

const声明的变量不能重复进行赋值, 否则将抛出TypeError错误

const声明的对象不能改变,但是对象中的属性可以进行改变。const绑定的是对象的引用,对象中实际的值是可以改变的。

'use strict';
const person = {
    name:'Mary'
};

person.name = 'Jim';
person = {
    name:'Bary'
}; // TypeError: Assignment to constant variable

3.4 临时死区

使用let和const声明的变量,只有在声明之后才能够使用,否则会触发ReferenceError错误,即使在ES5中可以安全使用的typeof关键字在ES6中也不能保证可以安全使用。这种特殊行为就叫做临时死区(Temporal Death Zone)。

'use strict';
if(true){
    console.log(typeof value); // ReferenceError: value is not defined

    const value = 'blue';
}

如上面代码,由于临时死区的存在,value变量在声明之前是不能被访问的。

当Javascript引擎遇到一个代码块并且代码块中存在变量声明,那么要么进行变量声明提升(hoisting),将变量提升到函数或者全局作用域顶部进行声明(使用var关键字);要么将变量放入临时性死区(使用const或者let关键字),尝试访问临时性死区中的变量将会导致ReferenceError错误。在遇到变量声明(const或者let关键字)后,该变量将被移出临时性死区,变量就可以被访问了。

'use strict';
console.log(typeof value); // undefined
if(true){
    let value = 'blue';
}

如上面代码,value变量并未放入临时性死区,使用typeof关键字仍然是安全的。

4. 循环

4.1 循环的块级作用域

实际开发中比较长使用的是在循环中使用块级作用域,在Javascript中,var关键字在循环中使用有着很多不被其他语言开发者了解的缺陷。

for(var i=0;i<10;i++){
    // do something
}

console.log(i); // 10

例如上面代码中,开发者希望达到的效果是i在循环之后不能访问,但是由于Javascript会进行变量声明“提升”,i在循环结束之后,仍然能够访问。

使用let关键字,可以有效避免这个问题。

for(let i=0;i<10;i++){
    // do something
}

console.log(i); // ReferenceError

4.2 函数的循环

使用var关键字创建的变量在循环内部的函数中使用有一些问题。例如下面的代码,开发者期待输出从0到9,但是由于i在循环之后仍然能够访问,funcs中的每个函数引用的是同一个i,因此在调用后输出了十次10。

var funcs = [];
for(var i = 0;i < 10;i++){
    funcs.push(function(){console.log(i);});
}

funcs.forEach(function(func){
    func(); // / outputs 10 ten times
});

上面的问题可以通过立即执行函数(Immidiately Invoked Function Expressions,IIFEs)来解决

var funcs = [];
for(var i = 0;i < 10;i++){
    funcs.push((function(val){
        return function(){console.log(val);};
    })(i));
}

funcs.forEach(function(func){
    func(); // outputs 0, then 1, then 2, up to 9
});

如上面的代码,使用立即执行函数强制将i作为参数传入到每个函数中,这样每个函数保存的是循环过程中i的副本,因此可以正确输出。

4.3 在循环中使用let

使用let关键字可以用比较简单清晰的代码解决上面的问题。

'use strict';
var funcs = [];
for(let i = 0;i < 10;i++){
    funcs.push(function(){console.log(i);});
}

funcs.forEach(function(func){
    func(); // outputs 0, then 1, then 2, up to 9
});

如上面代码,使用let会在每次循环过程中,创建一个新的变量i,因此每个函数读取到的是每次循环的i的副本,每个i的副本的值由循环初始化时i的值决定。

在for in和for of循环中,let关键字有同样的特性。如下面代码,在每次循环时创建一个新key绑定,这样每次循环都一个新的key变量,因此每个函数输出不同的key。如果使用var关键字代替let,那么所有函数将输出相同的值c。

var funcs = [],
    object = {
        a: true,
        b: true,
        c: true
    };

for (let key in object) {
    funcs.push(function() {
        console.log(key);
    });
}

funcs.forEach(function(func) {
    func();     // outputs "a", then "b", then "c"
});

注意:let关键字在循环中的特性在规范中定义,但是跟let关键字的“非提升”特性并不相关。实际上,早起的一些let实现并没有实现上述在循环中的特性。这些特性是逐渐添加的。

4.4 在循环中使用const

EcmaScript 6规范并没有在循环中使用const给予禁止,但是在不同的循环类型(for, for in, for of),其行为是不同的。在for循环中,const可以在循环初始化时使用,但是如果尝试修改其值,那么将会抛出错误。如下面代码,i在初始化时时没问题的,但是在调用i++时,将会发生TypeError错误,因为++操作尝试修改一个常量的值。

'use strict';

var funcs = [];
for(const i=0;i<10;i++){ // TypeError: Assignment to constant variable
    funcs.push(function(){
        console.log(i);
    });
}

在for in, for of循环中使用const关键字则不会发生错误

'use strict';
var funcs = [],
    object = {
        a: true,
        b: true,
        c: true
    };

// doesn't cause an error
for (const key in object) {
    funcs.push(function() {
        console.log(key);
    });
}

funcs.forEach(function(func) {
    func();     // outputs "a", then "b", then "c"
});

如上面代码,使用const关键字与let关键字的不同之处只在于,key变量在块中不能被修改。由于在for in, for of循环中,每次遍历都会绑定一个新的key而不是尝试修改原来的key,因此const关键字在for in, for of中使用是没问题的。

4.5 全局作用域

在全局作用域使用let或者const关键字与var是不同的。当在全局作用域使用var关键字时,创建一个新的全局变量,并将其绑定到全局对象的属性上。因此,可以使用var覆盖全局对象上已经存在的变量。

// in a browser
var RegExp = "Hello!";
console.log(window.RegExp);     // "Hello!"

var ncz = "Hi!";
console.log(window.ncz);        // "Hi!"

上面的代码中,window对象原有的RegExp被修改,ncz被定义为一个全局变量,并写入全局对象的属性上。

let与const关键字会创建在全局作用域创建一个变量,但是并不会写入到全局对象的属性。因此,let与const关键字创建的变量不会覆盖全局变量,而只能创建一个优先读取的“影子”变量。

// in a browser
let RegExp = "Hello!";
console.log(RegExp);                    // "Hello!"
console.log(window.RegExp === RegExp);  // false

const ncz = "Hi!";
console.log(ncz);                       // "Hi!"
console.log("ncz" in window);           // false

如上面代码,RegExp与window.RegExp是不同的,ncz也并不在window对象上。因此,当开发者不需要在全局对象上创建变量,使用let和const关键字在全局作用域创建对象相比var是安全的。

5. 现有的最佳实践

由于let关键字的特性更符合其他语言的习惯,不会产生var关键字导致的各种问题,因此尽量使用let关键字广被开发者倡导。

由于大部分变量实际上不会改变,而修改变量会导致不可测的bug,因此对于那些不会发生改变的变量,要使用const关键字