let和const

let

基本用法
ES6新增let命令，用来声明变量。用法类似var，但let声明的变量只在它所在得代码块内有效。

  // 情况1
  {
  let a = 10;
  var b = 1;
  }

  a // ReferenceError（引用错误）: a is not defined.
  b // 1

  // 情况2：let命令适用for循环
  for (let i = 0; i < 10; i++) {}   // 计数器i只在for循环体内有效，在循环体外引用就会报错

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

下面代码中，i变量是var声明的，在全局范围内有用。所以每次循环的i值都会被覆盖，所以最后输出的值为10。
```
var a = [];
for (var i = 0; i < 10; i++) {
a[i] = function () {
console.log(i);
};
}
a[6](); // 10
```
下面代码中，i变量是let声明的，当前的i只在本轮循环体内。下一次循环声明的是新变量i，所以输出是6。
```
  var a = [];
  for (let i = 0; i < 10; i++) {
  a[i] = function () {
  console.log(i);
  };
  }
  a[6](); // 6
```

不存在变量提升

console.log(foo); // 输出undefined
console.log(bar); // 报错ReferenceError

var foo = 2; // var声明的变量存在变量提升
let bar = 2;

暂时性死区(temporal dead zone,简称TDZ)
- 定义：只要在块级作用域内存在let命令，它所申明的变量就“绑定”了这个区域，不再受外部影响。
```
var tmp = 123;

if (true) {
tmp = 'abc'; // ReferenceError
let tmp;
}
```
- 说明：上面代码中，存在全局变量tmp，但是块级作用域内let又声明了一个局部变量tmp，导致后者绑定这个块级作用域，所以在let声明变量前，对tmp赋值会报错。
- ES6规定：区块中存在let``const命令，这个区块对该命令声明的变量，形成了封闭作用域。凡是在声明之前就使用该变量，就会报错。
- 总结：在代码块内，使用let命令声明变量之前，该变量都是不可用的。
```
if (true) {
  // TDZ开始
  tmp = 'abc'; // ReferenceError
  console.log(tmp); // ReferenceError

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

  tmp = 123;
  console.log(tmp); // 123
}
```
- 在let命令声明变量tmp之前，都属于变量tmp的“死区”。
- 暂时性死区的本质：只要一进入当前作用域，所要使用的变量就已经存在了，但是不可获取，只有等到声明变量的那一行代码出现，才可以获取和使用该变量。
不允许重复声明

  - 不允许在相同作用域内，重复声明同一个变量。
  - 不能在函数内部重新声明参数。
  ```
// 报错
  function () {
    let a = 10;
    var a = 1;
  }

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

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

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

  ```

块级作用域

ES5只有全局作用域和函数作用域，没有块级作用域，这带来很多不合理的场景。

场景一：内部变量可能覆盖外部变量

var tmp = new Date();

function f() {
  console.log(tmp);
  if (false) {
    var tmp = "hello world";
  }
}
f(); //undefined

//函数f执行后，输出结果为undefined，原因在于变量提升，导致内层的tmp变量覆盖了外层的tmp变量。

第二种场景，用来计数的循环变量泄露为全局变量。

var s = 'hello';

for (var i = 0; i < s.length; i++) {
  console.log(s[i]);
}

console.log(i); // 5
// 变量i只用来控制循环，循环结束后，它并没有消失，泄露成了全局变量。

ES6的块级作用域

let实际上为JavaScript新增了块级作用域。

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

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

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

内层作用域可以定义外层作用域的同名变量。

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

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

块级作用域和函数声明

ES5规定，函数只能在顶层作用域和函数作用域之中声明，不能在块级作用域声明。

```
// 根据ES5的规定以下1.2函数声明都是非法的
// 情况一
if (true) {
  function f() {}
}

// 情况二
try {
  function f() {}
  } catch(e) {
}
```

ES6 引入了块级作用域，明确允许在块级作用域之中声明函数。

```
// ES5严格模式
'use strict';
if (true) {
 function f() {}
}
// 报错

// ES6严格模式
'use strict';
if (true) {
  function f() {}
}
// 不报错
```

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!”，因为在if内声明的函数f会被提升到函数头部，实际运行的代码如下。


// ES5版本
function f() { console.log('I am outside!'); }
(function () {
  function f() { console.log('I am inside!'); }
  if (false) {
  }
  f();
}());

ES6 的运行结果得到“I am outside!”。因为块级作用域内声明的函数类似于let，对作用域之外没有影响，实际运行的代码如下
```
// ES6版本
function f() { console.log('I am outside!'); }
(function () {
 f();
}());
```

三条规则只对ES6的浏览器实现有效，其他环境的实现不用遵守，还是将块级作用域的函数声明当作let处理。
- 允许在块级作用域内声明函数。
- 函数声明类似于var，即会提升到全局作用域或函数作用域的头部。
- 同时，函数声明还会提升到所在的块级作用域的头部。

const

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

 const PI = 3.1415;
  PI // 3.1415

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

上面代码改变常亮值报错
const声明的变量不得改变值，这意味着，const一旦声明变量，就必须立即初始化，不能留到以后赋值。
const的特性与let命令相同(块级作用域、不存在变量提升、暂时性死区、不可重复赋值)
对于复合类型的变量（const声明的对象）
变量名不指向数据，而是指向数据所在的地址。const命令只是保证变量名指向的地址不变，并不保证该地址的数据不变，所以将一个对象声明为常量必须非常小心。
- ps: 可从简单和复杂的数据类型存储方式理解