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不允许在相同作用域内，重复声明同一个变量。

扫描二维码关注公众号，回复： 4098757 查看本文章

// 报错
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