一、Promise是什么？
       Promise是异步编程的一种解决方案，比传统的解决方案--回调函数和事件更合理和强大，由社区最早提出和实现，ES6将其写进了语言标准，统一了用法，原生提供了Promise对象；
       简单来说，Promise就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果，从语法上来说，Promise是一个对象，从它可以获取异步操作的消息，Promise提供统一的API，各种异步操作都可以用同样的方法进行处理；
       Promise对象的特点：
       ①对象的状态不受外界影响，Promise对象代表一个异步操作，有三种状态：pending(进行中)、fulfilled（已成功）、rejected(已失败)，只有异步操作的结果可以决定当前是哪一种状态，任何其他操作都无法改变这个状态；
       ②一旦状态改变，就不会再变，任何时候都可以得到这个结果，Promise对象的状态改变，只有两种可能：从pending变为fulfilled和从pending变为rejected，只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果，这时就称为resolved（已定型），如果改变已经发生了，再对Promise对象添加回调函数，也会立即得到这个结果，这与事件（Event）完全不同，事件的特点是：如果你错过了它，再去监听，是得不到结果的；
       Promise对象的优点：
       ①Promise对象将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数；
       ②Promise对象提供统一的接口，使得控制异步操作更加容易；
       Promise对象的缺点：
       ①无法取消Promise，一旦新建它就会立即执行，无法中途取消；
       ②如果不设置回调函数，Promise内部抛出的错误不会反应到外部；
       ③当处于pending状态时，无法得知目前进展到哪一个阶段（刚刚开始还是即将完成）；

二、Promise对象的基本用法
       Promise对象是一个构造函数，用来生成Promise实例；

// Promise实例
const promise = new Promise(function(resolve, reject) {
      // ... some code
      if ( /* 异步操作成功 */ ) {
        resolve(value);
      } else {
        reject(error);
      }
    });
// 为Promise实例指定回调函数
promise.then(function(value) {
  // success
}, function(error) {
  // failure
});

       Promise构造函数接受一个函数作为参数，这个函数的参数分别是resolve和reject两个函数，这两个函数由JavaScript引擎提供，不用自己部署；
       resolve函数：将Promise对象的状态由“未完成”变为“成功”（即从 pending 变为 resolved），在异步操作成功时调用，并将异步操作的结果作为参数传递出去；
       reject函数：将Promise对象的状态从“未完成”变为“失败”（即从 pending 变为 rejected），在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去；
       .then函数：将Promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数；then方法可以接受两个回调函数作为参数，第一个回调函数是Promise对象的状态变为resolved时调用，第二个回调函数是Promise对象的状态变为rejected时调用，其中第二个函数是可选的，不一定要提供，这两个函数都接受Promise对象传出的值作为参数；

// 一个实例
function timeout(ms) {
      return new Promise((resolve, reject) => {
        setTimeout(resolve, ms, 'done'); // resolve后才可以执行then
      });
    }

    timeout(100).then((value) => {
      console.log(value); // done
    });

// Promise 新建后就会立即执行
let promise=new Promise((resolve,reject)=>{
      console.log('Promise新建后立即执行');
      resolve(); // 如果没有这句，then永远不会执行
    })
    promise.then(()=>{
      console.log('回调方法then在所有同步任务执行完后执行');
    })
    console.log('同步任务');
    // Promise新建后立即执行
    // 同步任务
    // 回调方法then在所有同步任务执行完后执行

// 异步加载图片
function loadImageAsync(url) {
      return new Promise(function(resolve, reject) {
        const image = new Image();

        image.onload = function() {
          resolve(image); // 成功时resolve
        };

        image.onerror = function() { // 失败时reject
          reject(new Error('Could not load image at ' + url));
        };

        image.src = url;
      });
    }

// Promise操作Ajax
const getJSON = function(url) {
  const promise = new Promise(function(resolve, reject){
    const handler = function() {
      if (this.readyState !== 4) {
        return;
      }
      if (this.status === 200) {
        resolve(this.response);
      } else {
        reject(new Error(this.statusText));
      }
    };
    const client = new XMLHttpRequest();
    client.open("GET", url);
    client.onreadystatechange = handler;
    client.responseType = "json";
    client.setRequestHeader("Accept", "application/json");
    client.send();

  });

  return promise;
};

getJSON("/posts.json").then(function(json) {
  console.log('Contents: ' + json);
}, function(error) {
  console.error('出错了', error);
});
// 如果调用resolve函数和reject函数时带有参数，那么它们的参数会被传递给回调函数，reject函数的参数通常是Error对象的实例，表示抛出的错误；resolve函数的参数除了正常的值以外，还可能是另一个Promise实例；

// p1和p2都是Promise的实例，但是p2的resolve方法将p1作为参数，即一个异步操作的结果是返回另一个异步操作
// 此时p1的状态决定了p2的状态，如果p1的状态是pending，那么p2的回调函数就会等待p1的状态改变，如果p1的状态已经是resolved或者rejected，那么p2的回调函数将会立刻执行；
const p1 = new Promise((resolve, reject) => {
      setTimeout(() => reject(new Error('fail')), 3000)
    })
    const p2 = new Promise((resolve, reject) => {
      setTimeout(() => resolve(p1), 1000)
    })
    p2.then(result => console.log(result))
      .catch(error => console.log(error)) // Error: fail
// 上面的代码中，p1是一个Promise，3秒之后变成rejected，p2的状态在1秒之后改变，resolve方法返回的是p1
// 由于p2返回的是另一个Promise，导致p2自己的状态无效了，由p1的状态决定p2的状态，所以后面的then语句都变成针对p1，又过了2秒，p1变为rejected，导致触发catch方法指定的回调函数；

// 调用resolve或reject并不会终结Promise的参数函数的执行，代码中，调用resolve(1)后，后面的console.log(2)还是会执行，并且会首先打印出来，
// 这是因为立即resolved的Promise是在本轮事件循环的末尾执行，总是晚于本轮循环的同步任务；
new Promise((resolve, reject) => {
      resolve(1);
      console.log(2);
    }).then(r => {
      console.log(r);
    })
    // 2
    // 1

// 一般来说，调用resolve或reject以后，Promise的使命就完成了，后继操作应该放到then方法里面去，而不应该直接写在resolve或reject的后面，
// 所以最好在它们前面加上return语句，这样就不会有意外；
new Promise((resolve, reject) => {
      return resolve(1);
      console.log(2); // 2不会被打印
    }).then(r => {
      console.log(r);
    })
    // 1

三、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，就调用funB；

// 箭头函数写法
getJSON("/post/1.json").then(
  post => getJSON(post.commentURL)
).then(
  comments => console.log("resolved: ", comments),
  err => console.log("rejected: ", err)
);

四、Promise.prototype.catch()回调
       Promise.prototype.catch方法是.then(null,rejection)的别名，用于指定发生错误时的回调函数；

getJSON('/posts.json').then(function(posts) {
      // ...
    }).catch(function(error) {
      // 处理 getJSON 和 前一个回调函数运行时发生的错误
      console.log('发生错误！', error);
    });

上面代码中，getJSON方法返回一个 Promise 对象，如果该对象状态变为resolved，则会调用then方法指定的回调函数，如果异步操作抛出错误，状态就会变为rejected，就会调用catch方法指定的回调函数，处理这个错误，另外，then方法指定的回调函数，如果运行中抛出错误，也会被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));

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

// 写法二
// reject方法的作用，等同于抛出错误
const promise = new Promise(function(resolve, reject) {
  reject(new Error('test'));
});
promise.catch(function(error) {
  console.log(error);
});

// 如果 Promise 状态已经变成resolved，再抛出错误是无效的
// Promise 在resolve语句后面，再抛出错误，就不会再被捕获了，等于没有抛出，因为Promise的状态一旦改变，就永远保持该状态，不会再变了
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 对象的错误具有“冒泡”性质，会一直向后传递，直到被捕获为止，
// 也就是说，错误总是会被下一个catch语句捕获
// 三个 Promise 对象：一个由getJSON产生，两个由then产生，任何一个抛出的错误，都会被最后一个catch捕获
getJSON('/post/1.json').then(function(post) {
  return getJSON(post.commentURL);
}).then(function(comments) {
  // some code
}).catch(function(error) {
  // 处理前面三个Promise产生的错误
});

// 不要在then方法里面定义 Reject 状态的回调函数（即then的第二个参数），总是使用catch方法
// bad
promise
  .then(function(data) {
    // success
  }, function(err) {
    // error
  });

// good
// 可以捕获前面then方法执行中的错误，也更接近同步的写法（try/catch），因此，建议总是使用catch方法，而不使用then方法的第二个参数
promise
  .then(function(data) { //cb
    // success
  })
  .catch(function(err) {
    // error
  });

// 如果没有使用catch方法指定错误处理的回调函数，Promise对象抛出的错误不会传递到外层代码，不会有任何反应
const someAsyncThing = function() {
  return new Promise(function(resolve, reject) {
    // 下面一行会报错，因为x没有声明
    resolve(x + 2);
  });
};

someAsyncThing().then(function() {
  console.log('everything is great');
});

setTimeout(() => { console.log(123) }, 2000);
// Promise 内部的错误不会影响到 Promise 外部的代码，即“Promise 会吃掉错误”
// Uncaught (in promise) ReferenceError: x is not defined
// 123

// 代码中Promise指定下一轮“事件循环”再抛出错误，到了那个时候，Promise的运行已经结束了，所以这个错误在Promise函数体外抛出的，会冒泡到最外层，成了未捕获的错误；
const 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

// 运行完catch方法指定的回调函数，会接着运行后面then方法指定的回调函数，如果没有报错，则会跳过catch方法
const 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

const 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');
});
// oh no [ReferenceError: x is not defined]

someAsyncThing().then(function() {
  return someOtherAsyncThing();
}).catch(function(error) {
  console.log('oh no', error);
  // 下面一行会报错，因为y没有声明
  y + 2;
}).catch(function(error) { // 第二个catch方法用来捕获前一个catch方法抛出的错误
  console.log('carry on', error);
});
// oh no [ReferenceError: x is not defined]
// carry on [ReferenceError: y is not defined]

五、Promise.prototype.finally()
       finally方法用于指定不管 Promise 对象最后状态如何，都会执行的操作；

// 不管promise最后的状态，在执行完then或catch指定的回调函数以后，都会执行finally方法指定的回调函数
promise
.then(result => {···})
.catch(error => {···})
.finally(() => {···}); 

// 然后使用finally方法关掉服务器
server.listen(port)
  .then(function () {
    // ...
  })
  .finally(server.stop);

// finally本质上是then方法的特例
// finally方法的回调函数不接受任何参数，这意味着没有办法知道，前面的 Promise 状态到底是fulfilled还是rejected。这表明，finally方法里面的操作，应该是与状态无关的，不依赖于 Promise 的执行结果
promise
.finally(() => {
  // 语句
});

// 等同于
promise
.then(
  result => {
    // 语句
    return result;
  },
  error => {
    // 语句
    throw error;
  }
);

// finally方法为成功和失败两种情况只写一次
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 })
  );
};

// finally方法总是会返回原来的值
// resolve 的值是 undefined
Promise.resolve(2).then(() => {}, () => {})

// resolve 的值是 2
Promise.resolve(2).finally(() => {})

// reject 的值是 undefined
Promise.reject(3).then(() => {}, () => {})

// reject 的值是 3
Promise.reject(3).finally(() => {})

六、Promise.all()

// Promise.all方法用于将多个 Promise 实例，包装成一个新的 Promise 实例
// p1、p2、p3都是 Promise 实例，如果不是，就会先调用Promise.resolve方法，将参数转为 Promise 实例，再进一步处理；
// 只有p1、p2、p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1、p2、p3的返回值组成一个数组，传递给p的回调函数；
// 只要p1、p2、p3之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数
const p = Promise.all([p1, p2, p3]);

const promises = [2, 3, 5, 7, 11, 13].map(function(id) {
    return getJSON('/post/' + id + ".json");
  });

  Promise.all(promises).then(function(posts) {
    // ...
  }).catch(function(reason) {
    // ...
  });

// p2有自己的catch方法
const p1 = new Promise((resolve, reject) => {
  resolve('hello');
})
.then(result => result)
.catch(e => e);

const p2 = new Promise((resolve, reject) => {
  throw new Error('报错了');
})
.then(result => result)
.catch(e => e);

Promise.all([p1, p2])
.then(result => console.log(result))
.catch(e => console.log(e));
// ["hello", Error: 报错了]
// 上面代码中，p1会resolve，p2首先会rejected，但是p2有自己的catch方法，该方法返回的是一个新的Promise实例，p2指向的实际上是这个实例，该实例执行完catch方法后，也会变成resolved，导致Promise.all()方法参数里面的两个实例都会resolved，因此会调用then方法指定的回调函数，而不会调用catch方法指定的回调函数；

// 如果p2没有自己的catch方法，就会调用Promise.all()的catch方法
const p1 = new Promise((resolve, reject) => {
  resolve('hello');
})
.then(result => result);

const p2 = new Promise((resolve, reject) => {
  throw new Error('报错了');
})
.then(result => result);

Promise.all([p1, p2])
.then(result => console.log(result))
.catch(e => console.log(e));
// Error: 报错了

七、Promise.race()

// 只要p1、p2、p3之中有一个实例率先改变状态，p的状态就跟着改变，那个率先改变的 Promise 实例的返回值，就传递给p的回调函数；
const p = Promise.race([p1, p2, p3]);

// 如果5秒之内fetch方法无法返回结果，变量p的状态就会变为rejected，从而触发catch方法指定的回调函数
const p = Promise.race([
  fetch('/resource-that-may-take-a-while'),
  new Promise(function (resolve, reject) {
    setTimeout(() => reject(new Error('request timeout')), 5000)
  })
]);

p
.then(console.log)
.catch(console.error);

八、Promise.resolve()

// 将现有对象转为 Promise 对象
Promise.resolve('foo')
// 等价于
new Promise(resolve => resolve('foo'))

• 如果参数是 Promise 实例，那么Promise.resolve将不做任何修改、原封不动地返回这个实例；
• thenable对象

// thenable对象指的是具有then方法的对象
let thenable = {
  then: function(resolve, reject) {
    resolve(42);
  }
};
// Promise.resolve方法会将这个对象转为 Promise 对象，然后就立即执行thenable对象的then方法
let p1 = Promise.resolve(thenable);
p1.then(function(value) {
  console.log(value);  // 42
});

• 如果参数是一个原始值，或者是一个不具有then方法的对象，则Promise.resolve方法返回一个新的 Promise 对象，状态为resolved

// 返回 Promise 实例的状态从一生成就是resolved，所以回调函数会立即执行
const p = Promise.resolve('Hello');

p.then(function (s){
  console.log(s)
});
// Hello

• 不带有任何参数

// Promise.resolve方法允许调用时不带参数，直接返回一个resolved状态的 Promise 对象
const p = Promise.resolve();

p.then(function () {
  // ...
});

// 立即resolve的Promise对象，是在本轮“事件循环”（event loop）的结束时，而不是在下一轮“事件循环”的开始时；
setTimeout(function () {
  console.log('three');
}, 0);

Promise.resolve().then(function () {
  console.log('two');
});

console.log('one');

// one
// two
// three
// setTimeout(fn, 0)在下一轮“事件循环”开始时执行，Promise.resolve()在本轮“事件循环”结束时执行，console.log('one')则是立即执行，因此最先输出

九、Promise.reject()

// Promise.reject(reason)方法也会返回一个新的 Promise 实例，该实例的状态为rejected
const p = Promise.reject('出错了');
// 等同于
const p = new Promise((resolve, reject) => reject('出错了'))

p.then(null, function (s) {
  console.log(s)
});
// 出错了
// Promise.reject()方法的参数，会原封不动地作为reject的理由，变成后续方法的参数。这一点与Promise.resolve方法不一致

十、Promise.try()

// Promise.try就是模拟try代码块，就像promise.catch模拟的是catch代码块
try {
  database.users.get({id: userId})
  .then(...)
  .catch(...)
} catch (e) {
  // ...
}

十一、Promise链式调用

// 采用链式的then，可以指定一组按照次序调用的回调函数
function start() {
  return new Promise((resolve, reject) => {
    resolve('start');
  });
}

start()
  .then(data => {
    // promise start
    console.log('result of start: ', data);
    return Promise.resolve(1); // p1
  })
  .then(data => {
    // promise p1
    console.log('result of p1: ', data);
    return Promise.reject(2); // p2
  })
  .then(data => {
    // promise p2
    console.log('result of p2: ', data);
    return Promise.resolve(3); // p3
  })
  .catch(ex => {
    // promise p3
    console.log('ex: ', ex);
    return Promise.resolve(4); // p4
  })
  .then(data => {
    // promise p4
    console.log('result of p4: ', data);
  });

// 最终结果
result of start:  start
result of p1:  1
ex:  2
result of p4:  4

总结：代码的执行逻辑是 promise start --> promise p1 --> promise p3 --> promise p4，所以结合输出结果总结出以下几点：

• promise 的 then 方法里面可以继续返回一个新的 promise 对象；
• 下一个 then 方法的参数是上一个 promise 对象的 resolve 参数；
• catch 方法的参数是其之前某个 promise 对象的 rejecte 参数；
• 一旦某个 then 方法里面的 promise 状态改变为了 rejected，则promise 方法会连跳过后面的 then 直接执行 catch；
• catch 方法里面依旧可以返回一个新的 promise 对象；

function p1() {
  return new Promise((resolve) => {
    console.log(1);
    resolve();
  });
}

function p2() {
  return new Promise((resolve) => {
    console.log(2);
    resolve();
  });
}

function p3() {
  return new Promise((resolve) => {
    console.log(3);
    resolve();
  });
}

p1()
.then(() => {
  return p2();
})
.then(() => {
  return p3();
})
.then(() => {
  console.log('all done');
})
.catch(e => {
  console.log('e: ', e);
});

// 输出结果：
// 1
// 2
// 3
// all done

p1()
.then(() => {
  return Promise.all([
    p2(),
    p3(),
  ]);
})
.then(() => {
  console.log('all done');
})
.catch((e) => {
  console.log('e: ', e);
});
// 或者
Promise.all([p1(),p3(),p3()]).then(function(data){console.log(data)})
// 输出结果：
// 1
// 2
// 3
// all done

参考：
Promise 对象