《深入理解ES6》之块级作用域绑定

发表于 | 分类于 ，

var声明及变量提升（Hoisting）机制

在函数作用域或全局作用域钟通过关键字var声明的变量，都会被当成在当前作用域顶部声明的变量，这就是我们常说的提升（Hoisting）机制

1
2
3
4
5
6
7
8
9
10
function getValue(condition) {
    if(condition){
        var value = 'blue';
        return value;
    }else {
        //此处可以可访问变量value，其值为undefined
        return null;
    }
    //此处可以可访问变量value，其值为undefined    
}

在预编译阶段，JavaScript引擎会将上面的getValue函数修改成下面这样

1
2
3
4
5
6
7
8
9
function getValue(condition) {
    var value;
    if(condition){
        value = 'blue';
        return value;
    }else {
        return null;
    }
}

变量value的声明提升到函数顶部，初始化操作依然保留在原处执行，这就意味着在else语句中也可以访问到该变量，
且由于此时变量尚未初始化，所以其值为undefined

块级作用域

块级声明用于声明在指定块的作用域之外无法访问的变量，块级作用域存在于：

  • 函数内部
  • 块中（{}内部）

let 声明

let声明的用法与var相同，用let声明的变量作用域限制在当前代码块中。由于let声明不会被提升，所以通常
将let声明语句放在封闭代码块的顶部，以便整个代码块都可以访问。

1
2
3
4
5
6
7
8
9
10
function getValue(condition) {
    if(condition){
        let value = 'blue';
        return value;
    }else {
        //变量value，此处不存在
        return null;
    }
    //变量value，此处不存在
}

变量value该用let声明后，不再提升至函数顶部，if语句执行完后，value立刻被销毁。如果condition为
false，就永远不会声明并初始化value

禁止重复声明

如果作用域中已经存在某个标识符，此时再使用let关键字声明它就会抛出错误

1
2
3
4
var count = 30;
//抛出错误
let count = 40;

变量count被声明了两次，所以在let声明处会抛出错误。但如果当前作用域内嵌另一个作用域，便可以在内嵌作用域
中用let声明同名变量

1
2
3
4
5
var count = 30;
if(condition) {
    //不会抛出错误
    let count = 40;
}

const声明

关键字const用来声明一个常量，其值一旦设定后就不可更改。所以每个通过const声明的常量必须进行初始化。

1
2
3
4
const maxItems = 30;
//语法错误：常量未初始化
const name;

const与let

const与let声明的都是块级标识符，所以也只在当前代码块内有效，也不会被提升至作用域顶部，在同一作用域中
也不能重复声明

用const声明对象

const声明的变量不得改变值，对于引用类型数据，变量指向的内存地址，保存的是一个指针。const只能保证这个指针
是固定的，指针指向的数据结构是可变的。

1
2
3
4
5
6
7
8
9
10
const person = {
    name: 'Nico'
}
//可以修改对象属性的值
Nico.name = 'Greg';
//抛出语法错误
person = {
    name: 'Greg'
}

暂时死区（Temporal Dead Zone）

let和const声明的变量不会被提升到作用域顶部，如果在声明之前访问这些变量，即使相对安全的typeof操作符
也会触发引用错误

1
2
3
4
if(condition) {
    console.log(typeof value); //引用错误
    let value = 'blue';
}

由于console.log(typeof value)语句会抛出错误，因此用let定义并初始化变量value的语句不会执行，
此时value位于临时死区或TDZ中。

JavaScript引擎在扫描代码发现变量声明时，要么将它们提升至作用域顶部（var声明），要么将声明放到TDZ中（let和const）。
访问TDZ中的变量会出发运行时错误。只有执行过变量声明语句后，变量才会从TDZ中移出，然后方可正常访问。

循环中的块作用域绑定

循环中的函数

var声明在循环中创建函数变得异常困难，因为变量到了循环之外也能访问

1
2
3
4
5
6
7
8
9
10
11
var funcs = [];
for(var i = 0; i < 10; i++){
    funcs.push(function(){
        console.log(i)
    })
}
funcs.forEach(function(func) {
    func(); //输出10次数字10
});

这是因为循环里的每次迭代同时共享着变量i，循环内部创建的函数全都保留了对相同变量的引用。循环结束时变量
i的值为10，所以每次调用console.log(i)都会输出数字10

为了解决这个问题，可以使用立即调用函数表达式（IIFE），以强制生成计数器变量的副本。

1
2
3
4
5
6
7
8
9
10
11
12
13
var funcs = [];
for(var i = 0; i < 10; i++){
    funcs.push((function(value){
            return function(){
                console.log(value)
            }
        }(i)))
}
funcs.forEach(function(func) {
    func(); //0,1,...,9
});

在循环内部，IIFE表达式为接受的每一个变量i都创建了一个副本并存储为变量value。这个变量的值就是相应迭代创建
的函数所使用的值，因此调用每个函数都会像0到9循环一样得到期望的值。

循环中的let声明

用let来声明上述示例，那么每次迭代循环都会创建一个新变量，并以之前迭代中同名变量的值将其初始化

1
2
3
4
5
6
7
8
9
10
11
var funcs = [];
for(let i = 0; i < 10; i++){
    funcs.push(function(){
        console.log(i)
    })
}
funcs.forEach(function(func) {
    func(); //0,1,...,9
});

对于for-in循环和for-of循环，表现的行为和for循环保持一致。

循环中的const声明

对于普通的for循环，可以在初始化变量时使用const，但是更改这个变量的值就会抛出错误

1
2
3
4
5
6
var funcs = [];
for(const i = 0; i < 10; i++){
    funcs.push(function(){
        console.log(i)
    })
}

在for-in或for-of循环中使用const时的行为与使用let一致

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var funcs = [],
    obj = {
        a: true,
        b: false,
        c: true
    };
for(const key in obj){
    funcs.push(function(){
        console.log(key)
    })
}
funcs.forEach(function(func){
    func()
})

全局块作用域绑定

let和const与var的另外一个区别是它们在全局作用域的行为。当var被用于全局作用域时，它会创建一个新的全局
变量作为全局对象的属性。这意味着可能无意中覆盖了一个已经存在的全局变量。

而在全局作用域使用let或const，不会覆盖全局变量，只能遮蔽它。

1
2
3
4
5
6
7
//浏览器中
var RegExp = 'hello';
console.log(RegExp,window.RegExp);  //'hello' 'hello'
//浏览器中
let RegExp = 'hello';
console.log(RegExp,window.RegExp); // 'hello' function RegExt(){ [native code] }