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;
  })
}

第十四章 Promise对象