let和const命令

1、let命令

　　一、基本语法

　　ES6新增了let命令，用于声明变量。其语法与var相似，可是所声明的变量只在let命令所在的代码块内有效。

{
    let a = 1;
    var b = 2;
}
console.log(a); // ReferenceError: a is not defined
console.log(b); // 2

　　　上面的代码在代码块中分别用let和var声明了两个变量，而后在代码块以外调用这两个变量，结果let声明的变量报错，var声明的输出了正确的值。这代表，let声明的变量只在其所在的代码块内有效。

　　　下面来个经典的例子：

// var
{
    var arr = [];
    for (var i = 0; i < 10; i++) {
        arr[i] = function() {
            console.log(i);
        };
    }
    arr[3](); // 10
}

　　上面的代码中，变量i是var声明的，在全局范围内都有效，因此全局只有一个变量i。每一次循环，变量i的值都会发生改变，而循环内，被赋给数组arr的函数内部的console.log(i)中的i指向全局中的i。也就是说，全部数组arr的成员中的i指向的都是同一个i，致使运行时输出的是最后一轮的i值，也就是10。

// let
{
    var arr = [];
    for (let i = 0; i < 10; i++) {
        arr[i] = function() {
            console.log(i);
        };
    }
    arr[3](); // 3
}

　　　上面的代码中，变量是let声明的，当前的i只在本轮循环有效。因此每一次循环的i其实都是一个新的变量，因而最后输出的是3。你们可能会问，若是每一轮循环变量i都是从新声明的，那它怎么知道上一轮循环的值从而计算出本轮循环的值呢？这是由于JavaScript引擎内部会记住上一轮循环的值，初始化本轮的变量i时，就在上一轮循环的基础上进行计算。

　　　另外，for循环还有一个特别之处，就是设置循环变量的那一部分是一个父做用域，而循环体内部是一个单独的子做用域。

{
    for (let i = 0; i < 2; i++) {
        let i = 'SophiaLee';
        console.log(i);
    }
    // SophiaLee
    // SophiaLee
}

　　二、不存在变量提高

　　var命令会发生“变量提高”的现象，即变量能够在声明以前使用，值为undefined。这种现象多少是有些奇怪的，按照通常的逻辑，变量应该在声明语句以后才能使用。

　　为了纠正这种现象，let命令改变了语法行为，它所声明的变量必定要在声明后使用，不然会报错。

// var
{
    console.log(a); // undefined
    var a = 5;
}

// let
{
    console.log(b); // ReferenceError: b is not defined
    let b = 1;
}

　　在上面的代码中，变量a用var命令声明会发生变量提高，当脚本开始运行时，变量a就已经存在，可是没有值，因此输出undefined。变量b用let命令声明则不会发生变量提高。这代表在声明它以前，变量b是不存在的，这时若是用到它，就会抛出错误。

　　三、暂时性死区

　　只要块级做用域内存在let命令，它所声明的变量就“绑定”这个区域，再也不受外部的影响。

　　ES6明确规定，若是区块中存在let和const命令，则这个区域对这些命令声明的变量从一开始就造成封闭的做用域。只要在声明以前使用这些变量，就会报错。总之，在代码块内，使用let命令声明变量以前，该变量都是不可用的。这在语法上成为“暂时性死区（TDZ）”。

// 暂时性死区
{
    if (true) {
        // TDZ开始
        a = 1;
        console.log(a); // ReferenceError: a is not defined
        let a; // TDZ结束
        console.log(a); // undefined
        a = 2;
        console.log(a); // 2
    }
}

　　上面的代码中，在let命令声明变量a以前，都属于变量a的“死区”。

　　另外，有些“死区”比较隐蔽，不太容易发现。

{
    function a(x = y, y = 2) {
        return [x, y];
    }
    a();  // ReferenceError: y is not defined
}

　　上面的代码中，调用a函数之因此报错，是由于参数x的默认值等于另外一个参数y，而此时y尚未声明，属于“死区”。若是y的默认值是x，就不会报错。

{
    function a(x = 1, y = x) {
        return [x, y];
    }
    a();  // [1, 1]
}
{
    // 不报错
    var x = x;
    // 报错
    let x = x; // ReferenceError: x is not defined    
} 

　　总之，暂时性死区的本质就是，只要进入当前做用域，所要使用的变量已经存在，可是不可获取，只有等到声明变量的那一行代码出现，才能够获取和使用该变量。

　　四、不容许重复声明

　　let不容许在同一做用域内重复声明同一个变量。

{
    // 报错
    let a = 1;
    // var a = 2;
}
{
    function a(arg) {
        let arg;
    }
    a(); // SyntaxError: Identifier 'arg' has already been declared
}
{
    function a(arg) {
        {
            let arg; // 不报错
        }
    }
    a();
}

2、const命令

　　一、基本用法

　　const声明一个只读的常量。一旦声明，常量的值就不能改变。

{
    const PI = 3.1415926;
    console.log(PI); // 3.1415926

    PI = 4; // TypeError: Assignment to constant variable.
}

　　上面的代码说明改变常量的值会报错。

　　const声明的变量不得改变值，这意味着，const一旦声明常量，就必须当即初始化，不能留到后面赋值。（只声明不赋值会报错）

　　const的做用域与let命令相同：只在声明所在的块级做用域内有效。

　　const命令声明的变量也不会提高，一样存在暂时性死区，只能在声明以后使用。

　　二、本质

　　const实际上保证的并非变量的值不得改动，而是变量指向的那个内存地址不得改动。对于简单类型的数据（Number、String、Boolean）而言，值就保存在变量指向的内存地址中，所以等同于常量。但对于复合类型的数据（主要是对象和数组）而言，变量指向的内存地址保存的只是一个指针，const只能保证这个指针是固定的，至于它指向的数据结构是不可变的，这彻底不能控制。所以，将一个对象声明为常量时必须很是当心。

{
    const person = {};
    // 为person添加一个属性，能够成功
    person.name = 'SophiaLee';
    console.log(person.name); // SophiaLee

    // 将person指向另外一个对象，就会报错
    person = {}; // TypeError: Assignment to constant variable. 类型错误：赋值给常量变量

}

　　上面的代码中，常量person储存的是一个地址，这个地址指向的是一个对象。不可变的只是这个地址，即不能把person指向另外一个地址，但对象自己是可变的，因此依然能够为其添加新属性。

　　再看另外一个例子：

{
    const arr = [];
    arr.push('Hello'); // 可执行
    arr.length = 0; // 可执行
    arr = ['World']; // 报错 TypeError: Assignment to constant variable.
}

　　上面的代码中，常量arr是一个数组，这个数组自己是可写的，可是若是将另外一个数组赋值给arr，就会报错。