let和const命令

一、let命令

  1、基本语法

  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
}

  2、不存在变量提升

  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是不存在的,这时如果用到它,就会抛出错误。

  3、暂时性死区

  只要块级作用域内存在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    
} 

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

  4、不允许重复声明

  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();
}

二、const命令

  1、基本用法

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

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

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

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

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

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

  const命令声明的变量也不会提升,同样存在暂时性死区,只能在声明之后使用。

  2、本质

  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,就会报错。

 

  

 

  

posted @ 2020-04-06 10:52  SophiaLeeXJ  阅读(178)  评论(0编辑  收藏  举报