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 的「创建」过程被提升了，但是初始化没有提升。
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 &lt; 10; i++) {

  // ...

}

console.log(i);

// ReferenceError: i is not defined

var a = [];

for (let i = 0; i &lt; 10; i++) {

  a[i] = function () {

    console.log(i);

  };

}

a[6](); // 6

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

for (let i = 0; i &lt; 3; i++) {

  let i = 'abc';

  console.log(i);

}

// abc

// abc

// abc

/*

for( let i = 0; i&lt; 5; i++) 这句话的圆括号之间，有一个隐藏的作用域

for( let i = 0; i&lt; 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) =&gt; {

  Object.freeze(obj);

  Object.keys(obj).forEach( (key, i) =&gt; {

    if ( typeof obj[key] === 'object' ) {

      constantize( obj[key] );

    }

  });

};

// 常规模式时，下面一行不起作用；

// 严格模式时，该行会报错

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

块级作用域（同let）

重复声明（同let）

不存在变量提升（同let）

暂时性死区（同let）

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

原文地址：https://segmentfault.com/a/1190000017027339