ES6--作用域, let 和 const

总结：

1. let声明的变量，只在let命令所在的块级作用域内有效。
2. 没有变量提升
3. let死区
4. 不允许重复声明
5. 存在块级作用域 { }
6. 允许在块级作用域之中声明函数
7. const声明的变量和let基本一样，只是不能赋值改变

作用域

{} 大括号和 () 圆括号中（通常是for里面），是一个块级作用域

let声明变量，只在let命令所在的代码块内有效

{
  let a = 10;
  var b = 1;
}

a // ReferenceError: a is not defined.
b // 1

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

console.log(i);

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

for (let i = 0; i < 3; i++) {
  let i = 'abc';
  console.log(i);
}
for循环还有一个特别之处，就是设置循环变量的那部分是一个父作用域，而循环体内部是一个单独的子作用域

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

没有变量提升

// var 的情况
console.log(foo); // 输出undefined
var foo = 2;

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

let死区

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

var tmp = 123;

if (true) {
  tmp = 'abc'; // ReferenceError
  let tmp;
}

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

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

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

不允许重复声明

let a=1;
let a=2; // 报错 Identifier 'a' has already been declared

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

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

没有变量提升

var tmp = new Date();

function f() {
  console.log(tmp);
  if (false) {
    var tmp = 'hello world';
  }
}
f(); // undefined 函数内的tmp被提升到了 函数顶部console.log(tmp);打印undefined

块级作用域

带有{ }就构成一个块级作用域
ES5 只有全局作用域和函数作用域，没有块级作用域

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

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

函数声明

ES5 规定，函数只能在顶层作用域和函数作用域之中声明，不能在块级作用域声明。但是尽管做了，浏览器却不会报错
ES6 明确允许在块级作用域之中声明函数

const

变量指向的那个内存地址不得改动

const foo = {};

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

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

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