【读书笔记】ES6之用let,const和用var来声明变量的区别

# var(掌握)

# 不区分变量和常量

用 var 声明的变量都是变量，都是可变的，我们可以随便对它进行运算操作。这样当多个人进行同一个项目时，区分变量和常量会越来越难，一不小心就会把设计为常量的数据更改了。

# 允许重新声明

在相同作用域下用 var 声明的一个变量，当再次声明时，程序不会报错，并且会把该变量重新赋值。

# 存在变量提升

变量在声明它们的脚本或函数中都是有定义的，变量声明语句会被“提前”至脚本或者函数的顶部。但是初始化的操作则还在原来 var 语句的位置执行，在声明语句之前变量的值是 undefined。
需要注意的是，var 语句同样可以作为 for 循环或者 for/in 循环的组成部分（和在循环之外声明的变量声明一样，这里声明的变量也会“提前”）。

console.log('a:', a); //undefined
var a = 2;
function b() {
  console.log('c:', c); //undefined
  var c = 3;
  console.log('c:', c); //3
}
console.log('a:', a); //2

# 没有块级作用域

只有全局作用域和函数作用域，所有函数外的全局变量在程序的任何地方都是可见的，函数内部的变量只在函数内部可见，函数外无法访问该变量。

# 是顶层对象的属性

JavaScript 全局变量是全局对象的属性，这是在 ECMAScript 规范中强制规定的。对于局部变量则没有如此规定，但我们可以想象得到，局部变量当做跟函数调用相关的某个对象的属性。ECMAScript 5 规范称为“声明上下文对象”（declarative environment record）。

# let 声明变量（掌握）

# 不存在变量提升

let 命令改变了语法行为，它所声明的变量一定要在声明后使用，否则报错。

console.log(bar); // 报错ReferenceError
let bar = 2;

但是真的不存在变量提升吗？请看这些篇文章：

• let 深入理解---let 存在变量提升吗？
• 我用了两个月的时间才理解 let

看完这些文章，最后总结到：

• let 的「创建」过程被提升了，但是初始化没有提升。
• var 的「创建」和「初始化」都被提升了。
• function 的「创建」「初始化」和「赋值」都被提升了。

# 暂时性死区

ES6 明确规定，如果区块中存在 let 和 const 命令，这个区块对这些命令声明的变量，从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量，就会报错。
总之，在代码块内，使用 let 命令声明变量之前，该变量都是不可用的。这在语法上，称为“暂时性死区”（temporal dead zone，简称 TDZ）。 从块顶部到该变量的初始化语句，这块区域叫做 TDZ（临时死区）

if (true) {
  // TDZ开始
  tmp = 'abc'; // ReferenceError
  console.log(tmp); // ReferenceError

  let tmp; // TDZ结束
  console.log(tmp); // undefined

  tmp = 123;
  console.log(tmp); // 123
}

所谓暂时死区，就是不能在初始化之前，使用变量。

# 不允许重复声明

let 不允许在相同作用域内，重复声明同一个变量。

// 报错
function func() {
  let a = 10;
  var a = 1;
}
// 报错
function func() {
  let a = 10;
  let a = 1;
}

function func(arg) {
  let arg; // 报错
}
function func(arg) {
  {
    let arg; // 不报错
  }
}

# 块作用域

它的用法类似于 var，但是所声明的变量，只在 let 命令所在的代码块内有效。{}包裹就是一个作用域，用 let 声明的变量在{}中可见，在{}外面不可见。

function f1() {
  let n = 5;
  if (true) {
    let n = 10;
  }
  console.log(n); // 5
}

for 循环的计数器，就很合适使用 let 命令

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

console.log(i);
// ReferenceError: i is not defined

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

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

for (let i = 0; i < 3; i++) {
  let i = 'abc';
  console.log(i);
}
// abc
// abc
// abc
/*
for( let i = 0; i< 5; i++) 这句话的圆括号之间，有一个隐藏的作用域
for( let i = 0; i< 5; i++) { 循环体 } 在每次执行循环体之前，JS 引擎会把 i 在循环体的上下文中重新声明及初始化一次。
其他细节就不说了，太细碎了*/

ES6 允许块级作用域的任意嵌套

{
  {
    {
      {
        {
          let insane = 'Hello World';
        }
        console.log(insane); // 报错
      }
    }
  }
}
// 内层作用;

{
  {
    {
      {
        let insane = 'Hello World';
        {
          let insane = 'Hello World';
        }
      }
    }
  }
}

最后导致 IIFE 不再必要了

// IIFE 写法
(function () {
  var tmp = ...;
  ...
}());

// 块级作用域写法
{
  let tmp = ...;
  ...
}

# 扩展：块级作用域与函数声明

ES5 规定，函数只能在顶层作用域和函数作用域之中声明，不能在块级作用域声明。但是，浏览器没有遵守这个规定，为了兼容以前的旧代码，还是支持在块级作用域之中声明函数，因此实际都能运行，不会报错。

ES6 引入了块级作用域，明确允许在块级作用域之中声明函数。ES6 规定，块级作用域之中，函数声明语句的行为类似于 let，在块级作用域之外不可引用。

function f() {
  console.log('I am outside!');
}

(function() {
  if (false) {
    // 重复声明一次函数f
    function f() {
      console.log('I am inside!');
    }
  }

  f();
})(); //ES5 环境会得到“I am inside!”
//ES6 环境会得到“I am outside!”

为了减轻因此产生的不兼容问题，ES6 在附录 B 里面规定，浏览器的实现可以不遵守上面的规定，有自己的行为方式。

• 允许在块级作用域内声明函数。
• 函数声明类似于 var，即会提升到全局作用域或函数作用域的头部。
• 同时，函数声明还会提升到所在的块级作用域的头部。

允许在块级作用域内声明函数。 函数声明类似于 var，即会提升到全局作用域或函数作用域的头部。 同时，函数声明还会提升到所在的块级作用域的头部。上面的代码在符合 ES6 的浏览器中，都会报错，因为实际运行的是下面的代码。

// 浏览器的 ES6 环境
function f() {
  console.log('I am outside!');
}
(function() {
  var f = undefined;
  if (false) {
    function f() {
      console.log('I am inside!');
    }
  }

  f();
})();
// Uncaught TypeError: f is not a function

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

# 不是顶层对象的属性

顶层对象的属性与全局变量挂钩，被认为是 JavaScript 语言最大的设计败笔之一。这样的设计带来了几个很大的问题，首先是没法在编译时就报出变量未声明的错误，只有运行时才能知道（因为全局变量可能是顶层对象的属性创造的，而属性的创造是动态的）；其次，程序员很容易不知不觉地就创建了全局变量（比如打字出错）；最后，顶层对象的属性是到处可以读写的，这非常不利于模块化编程。另一方面，window 对象有实体含义，指的是浏览器的窗口对象，顶层对象是一个有实体含义的对象，也是不合适的。 用 let 命令声明的全局变量，不属于顶层对象的属性。

# const 声明常量（掌握）

# 值不能改变

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

const PI = 3.1415;
PI; // 3.1415

PI = 3;
// TypeError: Assignment to constant variable.

const 声明的变量不得改变值，这意味着，const 一旦声明变量，就必须立即初始化，不能留到以后赋值。

const foo;
// SyntaxError: Missing initializer in const declaration

# 本质

const 实际上保证的，并不是变量的值不得改动，而是变量指向的那个内存地址所保存的数据不得改动。对于简单类型的数据（数值、字符串、布尔值），值就保存在变量指向的那个内存地址，因此等同于常量。但对于复合类型的数据（主要是对象和数组），变量指向的内存地址，保存的只是一个指向实际数据的指针，const 只能保证这个指针是固定的（即总是指向另一个固定的地址），至于它指向的数据结构是不是可变的，就完全不能控制了。因此，将一个对象声明为常量必须非常小心。

const foo = {};

// 为 foo 添加一个属性，可以成功
foo.prop = 123;
foo.prop; // 123

// 将 foo 指向另一个对象，就会报错
foo = {}; // TypeError: "foo" is read-only

上面代码中，常量 foo 储存的是一个地址，这个地址指向一个对象。不可变的只是这个地址，即不能把 foo 指向另一个地址，但对象本身是可变的，所以依然可以为其添加新属性。
下面是一个将对象彻底冻结的函数

var constantize = obj => {
  Object.freeze(obj);
  Object.keys(obj).forEach((key, i) => {
    if (typeof obj[key] === 'object') {
      constantize(obj[key]);
    }
  });
};
// 常规模式时，下面一行不起作用；
// 严格模式时，该行会报错

# 不是顶层对象的属性（同 let）

# 块级作用域（同 let）

# 重复声明（同 let）

# 不存在变量提升（同 let）

# 暂时性死区（同 let）

其实 const 和 let 只有一个区别，那就是 const 只有「创建」和「初始化」，没有「赋值」过程。 在同一作用域中 const 的创建被提升了，初始化在 const 语句处才开始，所以有暂时性死区。
参考文章：

• ECMAScript 6 入门
• let 深入理解---let 存在变量提升吗？