1. Promise 的含义
Promise 是一种异步编程的解决方案，比传统的解决方案--回调函数和事件监听，更加合理和强大。
简单地说，Promise就是一个容器，里面保存着某个未来才会结束的事件(通常是一个异步操作)的结果
有两个特点：
(1) 对象的状态不受外界影响。Promise对象代表一个异步操作，有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态
(2) 一旦状态改变，就不会再变，任何时候都可以得到这个结果
有了Promise对象，就可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数。
Promise 缺点：
- 无法取消Promise，一旦新建，它就会立即执行，无法中途取消。
- 如果不设置回调函数，Promise内部抛出的错误，不会反应到外部
- 当处于pending状态时，无法得知目前进展到哪一个阶段
2. 基本用法
ES6规定，Promise对象是一个构造函数，用来生成Promise实例
const promise = new Promise(function(resolve, reject){
// ... some code
if ( /* 异步操作成功 */ ){
resolve(value);
} else {
reject(value);
}
})
resolve 的作用，将Promise对象的状态从“未成功”变为“成功”(即从pending变为resolved)，在异步操作成功时调用，并将异步操作的结果，作为参数传递出去。
reject函数的作用，将Promise对象的状态从“未完成”变为“失败”(即从pending变为rejected)，在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去。
Promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数。
promise.then(function(value){
// success
}, function(){
// failure
})
如果调用resolve函数和reject函数时带有参数，那么它们的参数会被传递给回调函数。
reject函数的参数通常是Error对象的实例，表示抛出错误；
resolve函数的参数除了正常的值以外，还可能是另一个Promise实例，比如：
const p1 = new Promise(function(resolve, reject){
// ...
})
const 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的回调函数将会立即执行。
const p1 = new Promise(function (resolve, reject) {
setTimeout(() => reject(new Error('fail')), 3000)
})
const p2 = new Promise(function (resolve, reject) {
setTimeout(() => resolve(p1), 1000)
})
p2
.then(result => console.log(result))
.catch(error => console.log(error))
// Error: fail
上面 由于p2返回的是另一个Promise，导致p2自己的状态无效了，由p1的状态决定p2的状态。
注意：调用resolve或reject并不会终结 Promise 的参数函数的执行
new Promise( (resolve, reject) => {
resolve(1);
console.log(2)
}).then( r => {
console.log(r)
})
// 2
// 1
new Promise((resolve, reject) => {
return resolve(1);
// 后面的语句不会执行
console.log(2);
})
3. Promise.prototype.then()
then方法返回的是一个新的Promise实例(注意，不是原来那个promise实例)，因此可以采用链式写法，即then方法后面再调用另一个then方法
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);
});
用箭头函数写法：
getJSON('/post/1.json').then{
post => getJSON(post.commentURL)
}.then(
comments => console.log("resolved: ", comments),
err => console.log('rejected: ', err)
);
4. Promise.prototype.catch()
Promise.prototype.catch方法是.then(null, rejection)的别名，用于指定发生错误时的回调函数
getJSON('/posts.json').then(function(posts){
// ...
}).catch(function(error){
// 处理getJSON和前一个回调函数运行时发生的错误
console.log('发生错误', error);
})
下面是一个例子：
const promise = new Promise(function(resolve, reject){
throw new Error('test')
})
promise.catch(function(error){
console.log(error)
})
// Error: test
上面代码中，promise抛出一个错误，就被catch方法指定的回调函数捕获
等价写法：
//写法一
const promise = new Promise(function(resolve, reject){
try {
throw new Error('test');
} catch (e){
reject(e)
}
})
promise.catch(function(error){
console.log(error)
})
//写法二
const promise = new Promise(function(resolve, reject){
reject(new Error('test'));
})
promise.catch(function(error){
console.log(error)
})
const 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 的状态一旦被改变，就永久保持该状态，不会再变了。
注意：一般来说，不要在then方法里面定义 Reject 状态的回调函数(即then的第二个参数)，而总是使用catch方法
// bad
promise
.then(function(){
// success
}, function(){
// error
})
// good
promise
.then(function(data){
// success
})
.catch(function(error){
// error
})
和传统的try/catch代码块不同的是，如果没有使用catch方法来接收错误，那么Promise对象抛出的错误不会传递到外层代码，即不会有任何反应
来看看这段代码：
const someAsyncThing = function(){
return new Promise(function(resolve, reject){
//下面一行会报错，因为x没有声明
resolve(x + 2);
})
}
someAsyncThing().then(function(){
console.log('everying is great');
})
setTimeout( () => console.log(123), 2000)
Promise内部发生错误，但是没有阻止123的执行
5. Promise.all()
用于将多个 Promise 实例，包装成一个新的Promise实例
const p = Promise.all([p1,p2,p3])
只有p1,p2,p3都成功，p才会成功。
如果p1,p2,p3有自己的catch方法，则首先会调用自己的catch方法。
6. Promise.race()
const p = Promise.race([p1,p2,p3])
上面代码中，只要p1,p2,p3之中有一个实例率先改变状态，p的状态就会跟着改变。那个率先改变的Promise实例的返回值，就传递给p的回调函数。
7. Promise.resolve()
将现有对象转为 Promise 对象
const jsPromise = Promise.resolve($.ajax('/whatever.json'));
上面代码将 Jquery 生成的 deferred 对象，转为一个新的 Promise 对象
Promise.resolve('foo')
//等价于
new Promise(resolve => resolve('foo'))
8. Promise.reject()
返回一个新的Promise实例，该实例的状态为rejected
9. 两个有用的方法
- done(): 处于回调链的尾端，保证抛出任何可能出现的错误。
实现原理：
Promise.prototype.done = function(onFulfilled, OnRejected){
this.then(onFulfilled, OnRejected)
.catch(function(reason){
//抛出一个全局错误
setTimeout(() => { throw reason }, 0);
})
}
- finally()
不管 Promise 对象最后状态如何，都会执行的操作。
实现原理
Promise.prototype.finally = function(callback){
let p = this.constructor;
return this.then(
value => P.resolve(callback()).then(() => value),
reason => P.resolve(callback()).then(() => { throw reason })
);
}
10. 应用
加载图片：
const preloadImage = function(path){
return new Promise(function(resolve, reject){
const image = new Image();
image.onload = resolve;
image.onerror = reject;
image.src = path;
})
}
