promise和let、const

 Promise 的含义
Promise 在JavaScript语言早有实现，ES6将其写进了语言标准，统一了用法，原生提供了Promise 对象。
所谓Promise ，就是一个对象，用来传递异步操作的消息。它代表了某个未来才会知道结果的事件（通常是一
个异步操作），并且这个事件提供统一的API，可供进一步处理。
Promise 对象有以下两个特点。
（1）对象的状态不受外界影响。Promise 对象代表一个异步操作，有三种状态：Pending （进行
中）、Resolved （已完成，又称Fulfilled）和Rejected （已失败）。只有异步操作的结果，可以决定当前是
哪一种状态，任何其他操作都无法改变这个状态。这也是Promise 这个名字的由来，它的英语意思就是“承
诺”，表示其他手段无法改变。
（2）一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise 对象的状态改变，只有两种可能：
从Pending 变为Resolved 和从Pending 变为Rejected 。只要这两种情况发生，状态就凝固了，不会再变了，
会一直保持这个结果。就算改变已经发生了，你再对Promise 对象添加回调函数，也会立即得到这个结果。这
与事件（Event）完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的。
有了Promise 对象，就可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数。此
外，Promise 对象提供统一的接口，使得控制异步操作更加容易。
Promise 也有一些缺点。首先，无法取消Promise ，一旦新建它就会立即执行，无法中途取消。其次，如果不
设置回调函数，Promise 内部抛出的错误，不会反应到外部。第三，当处于Pending 状态时，无法得知目前进
展到哪一个阶段（刚刚开始还是即将完成）。
如果某些事件不断地反复发生，一般来说，使用stream模式是比部署Promise 更好的选择。
2. 基本用法
ES6规定，Promise对象是一个构造函数，用来生成Promise实例。
下面代码创造了一个Promise实例。
var promise = new Promise(function(resolve, reject) {
// ... some code
if (/* 异步操作成功 */){
resolve(value);
} else {
reject(error);
}
});
Promise构造函数接受一个函数作为参数，该函数的两个参数分别是resolve 和reject 。它们是两个函数，由
Promise对象 - ECMAScript 6入门
http://es6.ruanyifeng.com/#docs/promise
JavaScript引擎提供，不用自己部署。
resolve 函数的作用是，将Promise对象的状态从“未完成”变为“成功”（即从Pending变为Resolved），在异
步操作成功时调用，并将异步操作的结果，作为参数传递出去；reject 函数的作用是，将Promise对象的状态
从“未完成”变为“失败”（即从Pending变为Rejected），在异步操作失败时调用，并将异步操作报出的错误，
作为参数传递出去。
Promise实例生成以后，可以用then方法分别指定Resolved状态和Reject状态的回调函数。
promise.then(function(value) {
// success
}, function(value) {
// failure
});
then 方法可以接受两个回调函数作为参数。第一个回调函数是Promise对象的状态变为Resolved时调用，第
二个回调函数是Promise对象的状态变为Reject时调用。其中，第二个函数是可选的，不一定要提供。这两个
函数都接受Promise对象传出的值作为参数。
下面是一个Promise对象的简单例子。
function timeout(ms) {
return new Promise((resolve, reject) => {
setTimeout(resolve, ms, 'done');
});
}
timeout(100).then((value) => {
console.log(value);
});
上面代码中，timeout 方法返回一个Promise实例，表示一段时间以后才会发生的结果。过了指定的时间（ms
参数）以后，Promise实例的状态变为Resolved，就会触发then 方法绑定的回调函数。
下面是异步加载图片的例子。
function loadImageAsync(url) {
return new Promise(function(resolve, reject) {
var image = new Image();
image.onload = function() {
resolve(image);
};
image.onerror = function() {
reject(new Error('Could not load image at ' + url));
};
image.src = url;
});
}
下面是一个用Promise对象实现的Ajax操作的例子。
var getJSON = function(url) {
var promise = new Promise(function(resolve, reject){
var client = new XMLHttpRequest();
Promise对象 - ECMAScript 6入门
http://es6.ruanyifeng.com/#docs/promise
client.open("GET", url);
client.onreadystatechange = handler;
client.responseType = "json";
client.setRequestHeader("Accept", "application/json");
client.send();
function handler() {
if ( this.readyState !== 4 ) {
return;
}
if (this.status === 200) {
resolve(this.response);
} else {
reject(new Error(this.statusText));
}
};
});
return promise;
};
getJSON("/posts.json").then(function(json) {
console.log('Contents: ' + json);
}, function(error) {
console.error('出错了', error);
});
上面代码中，getJSON 是对XMLHttpRequest对象的封装，用于发出一个针对JSON数据的HTTP请求，并且返
回一个Promise对象。需要注意的是，在getJSON 内部，resolve 函数和reject 函数调用时，都带有参数。
如果调用resolve 函数和reject 函数时带有参数，那么它们的参数会被传递给回调函数。reject 函数的参数
通常是Error对象的实例，表示抛出的错误；resolve 函数的参数除了正常的值以外，还可能是另一个Promise
实例，表示异步操作的结果有可能是一个值，也有可能是另一个异步操作，比如像下面这样。
var p1 = new Promise(function(resolve, reject){
// ...
});
var p2 = new Promise(function(resolve, reject){
// ...
resolve(p1);
})
上面代码中，p1 和p2 都是Promise的实例，但是p2 的resolve 方法将p1 作为参数，即一个异步操作的结果是
返回另一个异步操作。
注意，这时p1 的状态就会传递给p2 ，也就是说，p1 的状态决定了p2 的状态。如果p1 的状态是Pending ，那
么p2 的回调函数就会等待p1 的状态改变；如果p1 的状态已经是Resolved 或者Rejected ，那么p2 的回调函数
将会立刻执行。
var p1 = new Promise(function (resolve, reject) {
setTimeout(() => reject(new Error('fail')), 3000)
})
var p2 = new Promise(function (resolve, reject) {
setTimeout(() => resolve(p1), 1000)
})
p2.then(result => console.log(result))
p2.catch(error => console.log(error))
// Error: fail
Promise对象 - ECMAScript 6入门
http://es6.ruanyifeng.com/#docs/promise
上面代码中，p1 是一个Promise，3秒之后变为rejected 。p2 的状态由p1 决定，1秒之后，p2 调用resolve
方法，但是此时p1 的状态还没有改变，因此p2 的状态也不会变。又过了2秒，p1 变为rejected ，p2 也跟着变
为rejected 。
3. Promise.prototype.then()
Promise实例具有then 方法，也就是说，then 方法是定义在原型对象Promise.prototype上的。它的作用是
为Promise实例添加状态改变时的回调函数。前面说过，then 方法的第一个参数是Resolved状态的回调函
数，第二个参数（可选）是Rejected状态的回调函数。
then 方法返回的是一个新的Promise实例（注意，不是原来那个Promise实例）。因此可以采用链式写法，
即then 方法后面再调用另一个then 方法。
getJSON("/posts.json").then(function(json) {
return json.post;
}).then(function(post) {
// ...
});
上面的代码使用then 方法，依次指定了两个回调函数。第一个回调函数完成以后，会将返回结果作为参数，传
入第二个回调函数。
采用链式的then ，可以指定一组按照次序调用的回调函数。这时，前一个回调函数，有可能返回的还是一个
Promise对象（即有异步操作），这时后一个回调函数，就会等待该Promise对象的状态发生变化，才会被调
用。
getJSON("/post/1.json").then(function(post) {
return getJSON(post.commentURL);
}).then(function funcA(comments) {
console.log("Resolved: ", comments);
}, function funcB(err){
console.log("Rejected: ", err);
});
上面代码中，第一个then 方法指定的回调函数，返回的是另一个Promise对象。这时，第二个then 方法指定
的回调函数，就会等待这个新的Promise对象状态发生变化。如果变为Resolved，就调用funcA ，如果状态变
为Rejected，就调用funcB 。
如果采用箭头函数，上面的代码可以写得更简洁。
getJSON("/post/1.json").then(
post => getJSON(post.commentURL)
).then(
comments => console.log("Resolved: ", comments),
err => console.log("Rejected: ", err)
);
Promise对象 - ECMAScript 6入门
http://es6.ruanyifeng.com/#docs/promise
4. Promise.prototype.catch()
Promise.prototype.catch方法是.then(null, rejection) 的别名，用于指定发生错误时的回调函数。
getJSON("/posts.json").then(function(posts) {
// ...
}).catch(function(error) {
// 处理前一个回调函数运行时发生的错误
console.log('发生错误！', error);
});
上面代码中，getJSON 方法返回一个Promise对象，如果该对象状态变为Resolved，则会调用then 方法指定
的回调函数；如果异步操作抛出错误，状态就会变为Rejected，就会调用catch 方法指定的回调函数，处理这
个错误。
p.then((val) => console.log("fulfilled:", val))
.catch((err) => console.log("rejected:", err));
// 等同于
p.then((val) => console.log(fulfilled:", val))
.then(null, (err) => console.log("rejected:", err));
下面是一个例子。
var promise = new Promise(function(resolve, reject) {
throw new Error('test')
});
promise.catch(function(error) { console.log(error) });
// Error: test
上面代码中，Promise抛出一个错误，就被catch 方法指定的回调函数捕获。
如果Promise状态已经变成resolved，再抛出错误是无效的。
var promise = new Promise(function(resolve, reject) {
resolve("ok");
throw new Error('test');
});
promise
.then(function(value) { console.log(value) })
.catch(function(error) { console.log(error) });
// ok
上面代码中，Promise在resolve 语句后面，再抛出错误，不会被捕获，等于没有抛出。
Promise对象的错误具有“冒泡”性质，会一直向后传递，直到被捕获为止。也就是说，错误总是会被下一
个catch 语句捕获。
getJSON("/post/1.json").then(function(post) {
return getJSON(post.commentURL);
}).then(function(comments) {
// some code
}).catch(function(error) {
// 处理前面三个Promise产生的错误
Promise对象 - ECMAScript 6入门
http://es6.ruanyifeng.com/#docs/promise
});
上面代码中，一共有三个Promise对象：一个由getJSON 产生，两个由then 产生。它们之中任何一个抛出的错
误，都会被最后一个catch 捕获。
一般来说，不要在then 方法里面定义Reject状态的回调函数（即then 的第二个参数），总是使用catch 方
法。
// bad
promise
.then(function(data) {
// success
}, function(err) {
// error
});
// good
promise
.then(function(data) { //cb
// success
})
.catch(function(err) {
// error
});
上面代码中，第二种写法要好于第一种写法，理由是前者更接近同步的写法（try/catch）。
跟传统的try/catch代码块不同的是，如果没有使用catch 方法指定错误处理的回调函数，Promise对象抛出的
错误不会传递到外层代码，即不会有任何反应。
var someAsyncThing = function() {
return new Promise(function(resolve, reject) {
// 下面一行会报错，因为x没有声明
resolve(x + 2);
});
};
someAsyncThing().then(function() {
console.log('everything is great');
});
上面代码中，someAsyncThing 函数产生的Promise对象会报错，但是由于没有指定catch 方法，这个错误不会
被捕获，也不会传递到外层代码，导致运行后没有任何输出。
var promise = new Promise(function(resolve, reject) {
resolve("ok");
setTimeout(function() { throw new Error('test') }, 0)
});
promise.then(function(value) { console.log(value) });
// ok
// Uncaught Error: test
上面代码中，Promise指定在下一轮“事件循环”再抛出错误，结果由于没有指定使用try...catch语句，就冒泡
到最外层，成了未捕获的错误。因为此时，Promise的函数体已经运行结束了，所以这个错误是在Promise函
数体外抛出的。
Node.js有一个unhandledRejection 事件，专门监听未捕获的reject 错误。
Promise对象 - ECMAScript 6入门
http://es6.ruanyifeng.com/#docs/promise
process.on('unhandledRejection', function (err, p) {
console.error(err.stack)
});
上面代码中，unhandledRejection 事件的监听函数有两个参数，第一个是错误对象，第二个是报错的Promise
实例，它可以用来了解发生错误的环境信息。。
需要注意的是，catch 方法返回的还是一个Promise对象，因此后面还可以接着调用then 方法。
var someAsyncThing = function() {
return new Promise(function(resolve, reject) {
// 下面一行会报错，因为x没有声明
resolve(x + 2);
});
};
someAsyncThing()
.catch(function(error) {
console.log('oh no', error);
})
.then(function() {
console.log('carry on');
});
// oh no [ReferenceError: x is not defined]
// carry on
上面代码运行完catch 方法指定的回调函数，会接着运行后面那个then 方法指定的回调函数。如果没有报错，
则会跳过catch 方法。
Promise.resolve()
.catch(function(error) {
console.log('oh no', error);
})
.then(function() {
console.log('carry on');
});
// carry on
上面的代码因为没有报错，跳过了catch 方法，直接执行后面的then 方法。此时，要是then 方法里面报错，
就与前面的catch 无关了。
catch 方法之中，还能再抛出错误。
var someAsyncThing = function() {
return new Promise(function(resolve, reject) {
// 下面一行会报错，因为x没有声明
resolve(x + 2);
});
};
someAsyncThing().then(function() {
return someOtherAsyncThing();
}).catch(function(error) {
console.log('oh no', error);
// 下面一行会报错，因为y没有声明
y + 2;
}).then(function() {
console.log('carry on');
Promise对象 - ECMAScript 6入门
http://es6.ruanyifeng.com/#docs/promise
});
// oh no [ReferenceError: x is not defined]
上面代码中，catch 方法抛出一个错误，因为后面没有别的catch 方法了，导致这个错误不会被捕获，也不会
传递到外层。如果改写一下，结果就不一样了。
someAsyncThing().then(function() {
return someOtherAsyncThing();
}).catch(function(error) {
console.log('oh no', error);
// 下面一行会报错，因为y没有声明
y + 2;
}).catch(function(error) {
console.log('carry on', error);
});
// oh no [ReferenceError: x is not defined]
// carry on [ReferenceError: y is not defined]
上面代码中，第二个catch 方法用来捕获，前一个catch 方法抛出的错误。

let 命令
基本用法
ES6 新增了 let 命令，用来声明变量。它的用法类似于 var，但是所声明的变量，只在 let 命令所在的
代码块内有效。
{
let a = 10;
var b = 1;
}
a // ReferenceError: a is not defined.
b // 1
上面代码在代码块之中，分别用 let 和 var 声明了两个变量。然后在代码块之外调用这两个变量，结果 let 声
明的变量报错，var 声明的变量返回了正确的值。这表明，let 声明的变量只在它所在的代码块有效。
for 循环的计数器，就很合适使用 let 命令。
for (let i = 0; i < arr.length; i++) {}
console.log(i);
//ReferenceError: i is not defined
上面代码的计数器 i，只在 for 循环体内有效。
下面的代码如果使用 var，最后输出的是 10。
var a = [];
for (var i = 0; i < 10; i++) {
a[i] = function () {
console.log(i);
};
}
a[6](); // 10
上面代码中，变量 i 是 var 声明的，在全局范围内都有效。所以每一次循环，新的 i 值都会覆盖旧值，导致最
后输出的是最后一轮的 i 的值。
如果使用 let，声明的变量仅在块级作用域内有效，最后输出的是 6。
var a = [];
for (let i = 0; i < 10; i++) {
a[i] = function () {
console.log(i);
};
}
a[6](); // 6
上面代码中，变量 i 是 let 声明的，当前的 i 只在本轮循环有效，所以每一次循环的 i 其实都是一
个新的变量，所以最后输出的是 6。
不存在变量提升
let 不像 var 那样会发生“变量提升”现象。所以，变量一定要在声明后使用，否则报错。
console.log(foo); // 输出 undefined
console.log(bar); // 报错 ReferenceError
var foo = 2;
let bar = 2;
上面代码中，变量 foo 用 var 命令声明，会发生变量提升，即脚本开始运行时，变量 foo 已经存在了，但是
没有值，所以会输出 undefined。变量 bar 用 let 命令声明，不会发生变量提升。这表示在声明它之前，变
量 bar 是不存在的，这时如果用到它，就会抛出一个错误。
暂时性死区
只要块级作用域内存在 let 命令，它所声明的变量就“绑定”（binding）这个区域，不再受外部的影
响。
var tmp = 123;
if (true) {
tmp = 'abc'; // ReferenceError
let tmp;
}
上面代码中，存在全局变量 tmp，但是块级作用域内 let 又声明了一个局部变量 tmp，导致后者绑定这个
块级作用域，所以在 let 声明变量前，对 tmp 赋值会报错。
ES6 明确规定，如果区块中存在 let 和 const 命令，这个区块对这些命令声明的变量，从一开始就形成
了封闭作用域。凡是在声明之前就使用这些变量，就会报错。
总之，在代码块内，使用 let 命令声明变量之前，该变量都是不可用的。这在语法上，称为“暂时性死区”
（temporal dead zone，简称 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 命令声明变量 tmp 之前，都属于变量 tmp 的“死区”。
“暂时性死区”也意味着 typeof 不再是一个百分之百安全的操作。
typeof x; // ReferenceError
let x;
上面代码中，变量 x 使用 let 命令声明，所以在声明之前，都属于 x 的“死区”，只要用到该变量就会报错。因
此，typeof 运行时就会抛出一个 ReferenceError。
作为比较，如果一个变量根本没有被声明，使用 typeof 反而不会报错。
typeof undeclared_variable // "undefined"
上面代码中，undeclared_variable 是一个不存在的变量名，结果返回“undefined”。所以，在没有 let 之
前，typeof 运算符是百分之百安全的，永远不会报错。现在这一点不成立了。这样的设计是为了让大家养成良
好的编程习惯，变量一定要在声明之后使用，否则就报错。
有些“死区”比较隐蔽，不太容易发现。
function bar(x = y, y = 2) {
return [x, y];
}
bar(); // 报错
上面代码中，调用 bar 函数之所以报错（某些实现可能不报错），是因为参数 x 默认值等于另一个参
数 y，而此时 y 还没有声明，属于”死区“。如果 y 的默认值是 x，就不会报错，因为此时 x 已经声明
了。
function bar(x = 2, y = x) {
return [x, y];
}
bar(); // [2, 2]
ES6 规定暂时性死区和修订变量提升，主要是为了减少运行时错误，防止在变量声明前就使用这个变量，从而导
致意料之外的行为。这样的错误在 ES5 是很常见的，现在有了这种规定，避免此类错误就很容易了。
总之，暂时性死区的本质就是，只要一进入当前作用域，所要使用的变量就已经存在了，但是不可获取，只有等
到声明变量的那一行代码出现，才可以获取和使用该变量。
不允许重复声明
let 不允许在相同作用域内，重复声明同一个变量。
// 报错
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
}
上面的函数有两个代码块，都声明了变量 n，运行后输出 5。这表示外层代码块不受内层代码块的影
响。如果使用 var 定义变量 n，最后输出的值就是 10。
ES6 允许块级作用域的任意嵌套。
{{{{{let insane = 'Hello World'}}}}};
上面代码使用了一个五层的块级作用域。外层作用域无法读取内层作用域的变量。
{{{{
{let insane = 'Hello World'}
console.log(insane); // 报错
}}}};
内层作用域可以定义外层作用域的同名变量。
{{{{
let insane = 'Hello World';
{let insane = 'Hello World'}
}}}};
块级作用域的出现，实际上使得获得广泛应用的立即执行匿名函数（IIFE）不再必要了。
// IIFE 写法
(function () {
var tmp = ...;
...
}());
// 块级作用域写法
{
let tmp = ...;
...
}
块级作用域与函数声明
函数能不能在块级作用域之中声明，是一个相当令人混淆的问题。
ES5 规定，函数只能在顶层作用域和函数作用域之中声明，不能在块级作用域声明。
// 情况一
if (true) {
function f() {}
}
// 情况二
try {
function f() {}
} catch(e) {
}
上面代码的两种函数声明，根据 ES5 的规定都是非法的。
但是，浏览器没有遵守这个规定，还是支持在块级作用域之中声明函数，因此上面两种情况实际都能
运行，不会报错。不过，“严格模式”下还是会报错。
// ES5 严格模式
'use strict';
if (true) {
function f() {}
}
// 报错
ES6 引入了块级作用域，明确允许在块级作用域之中声明函数。
// 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 在附录 B 里面规定，浏
览器的实现可以不遵守上面的规定，有自己的行为方式。
• 允许在块级作用域内声明函数。
• 函数声明类似于 var，即会提升到全局作用域或函数作用域的头部。
• 同时，函数声明还会提升到所在的块级作用域的头部。
注意，上面三条规则只对 ES6 的浏览器实现有效，其他环境的实现不用遵守，还是将块级作用域的函数声明当作
let 处理。
前面那段代码，在老版本的 Chrome 环境下运行会报错。
// ES6 的浏览器环境
function f() { console.log('I am outside!'); }
(function () {
if (false) {
// 重复声明一次函数 f
function f() { console.log('I am inside!'); }
}
f();
}());
// Uncaught TypeError: f is not a function
上面的代码报错，是因为实际运行的是下面的代码。
// 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
考虑到环境导致的行为差异太大，应该避免在块级作用域内声明函数。如果确实需要，也应该写成函
数表达式，而不是函数声明语句。
// 函数声明语句
{
let a = 'secret';
function f() {
return a;
}
}
// 函数表达式
{
let a = 'secret';
let f = function () {
return a;
};
}
另外，还有一个需要注意的地方。ES6 的块级作用域允许声明函数的规则，只在使用大括号的情况下
成立，如果没有使用大括号，就会报错。
// 不报错
'use strict';
if (true) {
function f() {}
}
// 报错
'use strict';
if (true)
function f() {}
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 的作用域与 let 命令相同：只在声明所在的块级作用域内有效。
if (true) {
const MAX = 5;
}
MAX // Uncaught ReferenceError: MAX is not defined
const 命令声明的常量也是不提升，同样存在暂时性死区，只能在声明的位置后面使用。
if (true) {
console.log(MAX); // ReferenceError
const MAX = 5;
}
上面代码在常量 MAX 声明之前就调用，结果报错。
const 声明的常量，也与 let 一样不可重复声明。
var message = "Hello!";
let age = 25;
// 以下两行都会报错
const message = "Goodbye!";
const age = 30;
对于复合类型的变量，变量名不指向数据，而是指向数据所在的地址。const 命令只是保证变量名指
向的地址不变，并不保证该地址的数据不变，所以将一个对象声明为常量必须非常小心。
const foo = {};
foo.prop = 123;
foo.prop
// 123
foo = {}; // TypeError: "foo" is read-only
上面代码中，常量 foo 储存的是一个地址，这个地址指向一个对象。不可变的只是这个地址，即不能
把 foo 指向另一个地址，但对象本身是可变的，所以依然可以为其添加新属性。
下面是另一个例子。
const a = [];
a.push('Hello'); // 可执行
a.length = 0; // 可执行
a = ['Dave']; // 报错
上面代码中，常量 a 是一个数组，这个数组本身是可写的，但是如果将另一个数组赋值给 a，就会报错。
如果真的想将对象冻结，应该使用 Object.freeze 方法。
const foo = Object.freeze({});
// 常规模式时，下面一行不起作用；
// 严格模式时，该行会报错
foo.prop = 123;
上面代码中，常量 foo 指向一个冻结的对象，所以添加新属性不起作用，严格模式时还会报错。
除了将对象本身冻结，对象的属性也应该冻结。下面是一个将对象彻底冻结的函数。
var constantize = (obj) => {
Object.freeze(obj);
Object.keys(obj).forEach( (key, value) => {
if ( typeof obj[key] === 'object' ) {
constantize( obj[key] );
}
});
};
ES5 只有两种声明变量的方法：var 命令和 function 命令。ES6 除了添加 let 和 const 命令，后
面章节还会提到，另外两种声明变量的方法：import 命令和 class 命令。所以，ES6 一共有 6 种
声明变量的方法。
全局对象的属性
全局对象是最顶层的对象，在浏览器环境指的是 window 对象，在 Node.js 指的是 global 对象。
ES5 之中，全局对象的属性与全局变量是等价的。
window.a = 1;
a // 1
a = 2;
window.a // 2
上面代码中，全局对象的属性赋值与全局变量的赋值，是同一件事。（对于 Node 来说，这一条只对 REPL 环境适
用，模块环境之中，全局变量必须显式声明成 global 对象的属性。）
未声明的全局变量，自动成为全局对象 window 的属性，这被认为是 JavaScript 语言最大的设计败笔之一。这样
的设计带来了两个很大的问题，首先是没法在编译时就报出变量未声明的错误，只有运行时才能知道，其次程序
员很容易不知不觉地就创建了全局变量（比如打字出错）。另一方面，从语义上讲，语言的顶层对象是一个有实
体含义的对象，也是不合适的。
ES6 为了改变这一点，一方面规定，为了保持兼容性，var 命令和 function 命令声明的全局变量，依旧是全
局对象的属性；另一方面规定，let 命令、const 命令、class 命令声明的全局变量，不属于全局对象的属性。
也就是说，从 ES6 开始，全局变量将逐步与全局对象的属性脱钩。
var a = 1;
// 如果在 Node 的 REPL 环境，可以写成 global.a
// 或者采用通用方法，写成 this.a
window.a // 1
let b = 1;
window.b // undefined
上面代码中，全局变量 a 由 var 命令声明，所以它是全局对象的属性；全局变量 b 由 let 命令声
明，所以它不是全局对象的属性，返回 undefined。