es6中的Let和Const详解

// 只在所在的代码块生效
{
  let a = 10;
  var b = 1;
}

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

============

for (var i = 0; i < 5; i++) {
    console.log(i) // 0 1 2 3 4
}
console.log(i) // 5 i成了全局变量

==============

for (let j = 0; j < 5; j++) {
    console.log(j) // 0 1 2 3 4
}
// let定义的j变量只在for循环的块级作用域中生效，不存在变量提升
console.log(j) // Uncaught ReferenceError: j is not defined

var a = []
for (let i = 0; i < 10; i++) {
    a[i] = function () {
        console.log(i)
    }
}
console.log(a[6]()) // 6
console.log(i) // Uncaught ReferenceError: i is not defined

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

for (let i = 0; i < 3; i++) {
    let i = 'abc'
    console.log(i)
}

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

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

var tmp = 123;

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

===============

var i = 5;
(function () {
  console.log(i) // undefined
  var i = 10
})()

===============

let j = 55;
(function () {
  console.log(j) // ReferenceError: j is not defined
  let j = 77
})()

===============

(function hhh() {
  console.log(j) // j的临时性死区 Uncaught ReferenceError: j is not defined
  let j = 77 // 从这个函数的开始部分到这里，都是新的j的临时性死区
})()

调用bar函数之所以报错（某些实现可能不报错），是因为参数x默认值等于另一个参数y，而此时y还没有声明，属于“死区”。

function bar(x = y, y = 2) {
  return [x, y];
}

bar(); // 报错

下面的代码也会报错，与var的行为不同。

// 不报错
var x = x;

// 报错
let x = x;
// ReferenceError: x is not defined

上面代码报错，也是因为暂时性死区。使用let声明变量时，只要变量在还没有声明完成前使用，就会报错。上面这行就属于这个情况，在变量x的声明语句还没有执行完成前，就去取x的值，导致报错”x 未定义“。

let zxx = 'zxx is a great girl'
let zxx = 'zxx is 18 years old' // Uncaught SyntaxError: Identifier 'zxx' has already been declared

=================

let zxx3 = 'zxx is a great girl'
var zxx3 = 'zxx is 18 years old' // Uncaught SyntaxError: Identifier 'zxx3' has already been declared

==============
{
let zxx3 = 'zxx is a great girl'
var zxx4 = 'zxx is 18 years old'
}

{
let zxx3 = 'zxx is a good girl'
var zxx4 = 'zxx is 8 years old'
}
// 不会报错，各个块级作用域之间不互相影响

不能在函数内部重新声明参数。

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

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

const b; // Uncaught SyntaxError: Missing initializer in const declaration

对于基本的类型而言的话，比如number,string,boolean等来说，确实它就是声明一个不会变的常量，只要你修改了它，就会报错

const ZXX = 'zxx is a great girl'
ZXX = 'NO' // Uncaught TypeError: Assignment to constant variable.

不过，对于引用类型而言的话，它指的并不会对象的内容不变，而是对象的地址不变。也就是说，你可以修改对象的内部成员，但是你不可以修改该变量的地址。

const ZXX = {
  age: 18,
  name: 'zxx'
}
ZXX ==> {age: 18, name: "zxx"}
ZXX.age = 8 {age: 8, name: "zxx"}
ZXX.weight = 90 {age: 8, name: "zxx", weight: 90}

ZXX = {} // Uncaught TypeError: Assignment to constant variable.
// 修改了ZXX的指针，这是不允许的

因为对象是引用类型的，ZXX中保存的仅是对象的指针，这就意味着，const仅保证指针不发生改变，修改对象的属性不会改变对象的指针，所以是被允许的。也就是说const定义的引用类型只要指针不发生改变，其他的不论如何改变都是允许的。

const a = [];
a.push('Hello'); // 可执行
a.length = 0;    // 可执行
a = ['Dave'];    // 报错

const foo = Object.freeze({});

// 常规模式时，下面一行不起作用；
// 严格模式时，该行会报错
foo.prop = 123;

上面代码中，常量 foo指向一个冻结的对象，所以添加新属性不起作用，严格模式时还会报错。

var constantize = (obj) => {
    Object.freeze(obj)
    Object.keys(obj).forEach((key, i) => {
        if (typeof obj[key] === 'object') {
            constantize(obj[key])
        }
    })
}

window.a = 1;
a // 1

a = 2;
window.a // 2

上面代码中，顶层对象的属性赋值与全局变量的赋值，是同一件事。

var a = 1;
// 如果在 Node 的 REPL 环境，可以写成 global.a
// 或者采用通用方法，写成 this.a
window.a // 1

let b = 1;
window.b // undefined