ES6 API 之块级作用域、let和const 命令

在了解这两个API前，我们先了解一下块级作用域这个概念。

定义：

是一个语句，将多个操作封装在一起，通常是放在一个大括号里，没有返回值。

为何需要块级作用域?

在ES6之前，函数只能在全局作用域和函数作用域中声明，不能在块级作用域中声明。没有块级作用域导致很多场景不合理：

1. 内存变量可能覆盖外层变量

var a = 33;
function test() {
  console.log(a)
  if(false) {
    var a = 'eee';
  }
}
test();  // undefined 

输出的结果为undefined，是因为变量提升导致内层的 a 变量覆盖了外层的 a 变量。

2. 用来计数的循环变量泄露为全局变量

for (var i = 0; i < 10; i++) {    
        console.log(i);    
}    
console.log(i);  // 10 

上面的变量i 只是用来控制循环，但是循环之后，并没有消失，而是泄露为全局变量了。

ES6中的块级作用域：

1. 允许块级作用域任意嵌套，外层作用域无法读取内层作用域的变量

{{{{  
    {let i = 6;}  
    console.log(i);  // 报错  
}}}} 

2. 内层作用域可以定义外层作用域的同名变量

{{{{  
    let i = 5;  
    {let i = 6;}  
}}}} 

3. 不需要立即执行匿名函数
   立即执行函数：

(function() {
  var  a = 0;
}()); 

块级作用域：

{
    var a = 0;
} 

块级作用域中的函数声明

运行环境：ES6浏览器。
可实现的行为：

1. 允许在块级作用域内声明函数
2. 函数声明类似于var， 即会提升到全局作用域或函数作用域的头部
3. 函数声明还会提升到所有块级作用域的头部

function func() {  
    console.log(‘out’);  
}  
(function() {  
    var func = undefined;  
    if (false) {  
        function func() {  
            console.log(‘in’);  
        }  
    }  
    func();  
})(); 

考虑到环境导致的差异太大，应该避免在块级作用域中声明函数，如果需要，应该写成函数表达式的形式，而不是函数声明语句：

 let func= function func() {  
        console.log(‘in’);  
    }; 

ES6的块级作用域允许声明函数的规则只在使用大括号的情况下成立：

'use strict':  
if (true) {  
    function func1() {} // 不报错  
}  
if (true)  
    function func2() {} // 报错 

在了解完块级作用域后，我们来看看 let 命令：

什么是 let ？

let 是ES 用于声明变量的命令，与 var 类似，与之不同的是：

1. let 声明的变量只在块级作用域内有效
2. 不存在变量提升，而是“绑定”在暂时性死区
3. 不能重复声明

let 声明的变量只在块级作用域内有效

'use strict';
function func(args){
    if(true){
        let i = 6;
        console.log('inside: ' + i);  //不报错
    }
    console.log('outside: ' + i);  // 报错 "i is not defined"
};
func(); 

不存在变量提升，而是“绑定”在暂时性死区

// 不存在变量提升
'use strict';
function func(){
    console.log(i);
    let i;
};
func(); // 报错 

在let声明变量前，使用该变量，它是会报错的，而不是像var那样会‘变量提升’。
其实说let没有‘变量提升’的特性，不太对。或者说它提升了，但是ES6规定了在let声明变量前不能使用该变量。

'use strict';
var test = 1;
function func(){
    console.log(test);
    let test = 2;
};
func();  // 报错 

如果let声明的变量没有变量提升，应该打印’1’（func函数外的test）；而它却报错，说明它是提升了的，只是规定了不能在其声明之前使用而已。我们称这特性叫“暂时性死区（temporal dead zone）”。且这一特性，仅对遵循‘块级作用域’的命令有效（let、const）。

let使用经典案例：let命令代替闭包功能
闭包实现：

var arr = [];
for(var i = 0; i < 2; i++){
    arr[i] = (function(i){
        return function(){
            console.log(i);
        };
    }(i));
};
arr[1]();

let 实现：

'use strict';
var arr = [];
for(let i = 0; i < 2; i++){
    arr[i] = function(){
        console.log(i);
    };
};
arr[1](); 

剩下 const 命令了！
const 与 let 的使用规范一样，与之不同的是：
const 声明的是一个常量，且这个常量必须赋值，否则会报错。

'use strict';
function func(){
    const PI;
    PI = 3.14;
    console.log(PI);
};
func(); // 报错“Missing initializer in const declaration” 

let 和 const 就介绍到这，下期介绍变量的解构。