PromisePromise 是异步编程的一种解决方案。 Promise 是一个对象，通过它可以获取异步操作的消息。两

1 Promise

Promise 是异步编程的一种解决方案。
Promise 是一个对象，通过它可以获取异步操作的消息。
两个特点：对象的状态不受外界影响；一旦状态改变，就不会再改变。

1.1 Promise状态

有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。
只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。
一旦状态改变，就不会再变，任何时候都可以得到这个结果。
Promise对象的状态改变，只有两种可能：从pending变为fulfilled和从pending变为rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果，这时就称为resolved（已定型）。
如果改变已经发生了，你再对Promise对象添加回调函数，也会立即得到这个结果。
与事件（Event）完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的。
有了Promise对象，就可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数。

1.2 Promise的缺点

无法取消Promise，一旦新建它就会立即执行，无法中途取消。
如果不设置回调函数，Promise内部抛出的错误，不会反应到外部。
处于pending状态时，无法得知目前进展到哪一个阶段（刚刚开始还是即将完成）。

1.3 基本用法

ES6 规定，Promise对象是一个构造函数，用来生成Promise实例。
Promise构造函数接受一个函数作为参数，该函数的两个参数分别是resolve和reject函数，由 JavaScript 引擎提供，不用自己部署。
resolve函数的作用是，将Promise对象的状态从 pending 变为 resolved，在异步操作成功时调用，并将异步操作的结果，作为参数传递出去;
reject函数的作用是，将Promise对象的状态从从 pending 变为 rejected，在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去;
Promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数。

promise.then(function(value) {
  // success
}, function(error) {
  // failure
});

then方法可以接受两个回调函数作为参数。
第一个回调函数是Promise对象的状态变为resolved时调用，
第二个回调函数是Promise对象的状态变为rejected时调用。
第二个函数是可选的，不一定要提供。
这两个函数都接受Promise对象传出的值作为参数。

Promise 新建后就会立即执行。

let promise = new Promise(function(resolve, reject) {
  console.log('Promise');
  resolve();
});

promise.then(function() {
  console.log('resolved.');
});

console.log('Hi!');

// Promise
// Hi!
// resolved

Promise 新建后立即执行，所以首先输出的是Promise。
然后，then方法指定的回调函数，将在当前脚本所有同步任务执行完才会执行，所以resolved最后输出。

调用resolve或reject并不会终结 Promise 的参数函数的执行。

new Promise((resolve, reject) => {
  resolve(1);
  console.log(2);
}).then(r => {
  console.log(r);
});
// 2
// 1

调用resolve(1)以后，后面的console.log(2)还是会执行，并且会首先打印出来。
这是因为立即 resolved 的 Promise是在本轮事件循环的末尾执行，总是晚于本轮循环的同步任务。

如果调用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

上面代码中，p1是一个 Promise，3 秒之后变为rejected。
p2的状态在 1 秒之后改变，resolve方法返回的是p1。
由于p2返回的是另一个 Promise，导致p2自己的状态无效了，由p1的状态决定p2的状态。
所以，后面的then语句都变成针对后者（p1）。
又过了 2 秒，p1变为rejected，导致触发catch方法指定的回调函数。

then方法返回的是一个新的Promise实例（注意，不是原来那个Promise实例）,因此可以链式调用
Promise.prototype .catch方法是.then(null, rejection)或.then(undefined, rejection)的别名 ，用于指定发生错误时的回调函数。
Promise 对象的错误具有“冒泡”性质，会一直向后传递，直到被捕获为止。也就是说，错误总是会被下一个catch语句捕获。
catch 可以捕获前面then方法执行中的错误，也更接近同步的写法（try/catch）。因此，建议总是使用catch方法，而不使用then方法的第二个参数。
如果Promise 状态已经变成resolved，再抛出错误无效。因为状态不可改变。
一般总是建议，Promise 对象后面要跟catch方法，这样可以处理 Promise 内部发生的错误。
catch方法返回的还是一个Promise对象，因此后面还可以接着调用then方法。
跟传统的try/catch代码块不同的是，如果没有使用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);
// Uncaught (in promise) ReferenceError: x is not defined
// 123

someAsyncThing函数产生的 Promise 对象，内部有语法错误。
浏览器运行到这一行，会打印出错误提示ReferenceError: x is not defined，
但是不会退出进程、终止脚本执行，2 秒之后还是会输出123。
这就是说，Promise 内部的错误不会影响到 Promise外部的代码，
通俗的说法就是“Promise 会吃掉错误”。

finally方法用于指定不管Promise对象最后状态如何，都会执行的操作。该方法是 ES2018 引入标准的。
finally方法的回调函数不接受任何参数，这意味着没有办法知道，前面的 Promise 状态到底是fulfilled还是rejected。
finally方法里面的操作，应该是与状态无关的，不依赖于 Promise 的执行结果。
finally方法总是会返回原来的值。

1.4 Promise方法

Promise.all()

将多个 Promise 实例，包装成一个新的 Promise 实例
接受一个数组作为参数，p1、p2、p3都是 Promise 实例
如果不是，就会先调用下面讲到的Promise.resolve方法，将参数转为 Promise 实例，再进一步处理。
Promise.all()方法的参数可以不是数组，但必须具有 Iterator 接口，且返回的每个成员都是 Promise 实例。
全部完成返回、有一个失败则返回
如果作为参数的 Promise实例，自己定义了catch方法，那么它一旦被rejected，并不会触发Promise.all()的catch方法。实例执行完catch方法后，也会变成resolved

Promise.race()

有一个示例状态改变，则返回

Promise.allSettled()

该方法由 ES2020 引入,全部改变才返回
该方法返回的新的 Promise实例，一旦结束，状态总是fulfilled，不会变成rejected。
用于确定所有请求都结束

Promise.any()

一个完成则返回，全部失败则返回
目前是一个第三阶段的提案

1.5 Promise.resolve()

将一个对象转成Promise对象。

1.5.1 参数是一个 Promise 实例

Promise.resolve将不做任何修改、原封不动地返回这个实例。

1.5.2 参数是一个thenable对象

resolve方法会将这个对象转为Promise对象，然后就立即执行thenable对象的then方法。

let thenable = {
  then: function(resolve, reject) {
    resolve(42);
  }
};

let p1 = Promise.resolve(thenable);
p1.then(function(value) {
  console.log(value);  // 42
});

thenable对象的then方法执行后，对象p1的状态就变为resolved，
从而立即执行最后那个then方法指定的回调函数，输出 42。

1.5.3 参数不是具有then方法的对象，或根本就不是对象

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

const p = Promise.resolve('Hello');

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

由于字符串Hello不属于异步操作（判断方法是字符串对象不具有 then 方法），
返回 Promise 实例的状态从一生成就是resolved，所以回调函数会立即执行。
Promise.resolve方法的参数，会同时传给回调函数。

1.5.4 不带有任何参数

直接返回一个resolved状态的 Promise 对象。

如果希望得到一个 Promise对象，比较方便的方法就是直接调用Promise.resolve()方法。

const p = Promise.resolve();

p.then(function () {
  // ...
});
上面代码的变量p就是一个 Promise 对象。

注意：立即resolve()的 Promise 对象，是在本轮“事件循环”的结束时执行，而不是在下一轮“事件循环”的开始时。


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')则是立即执行，因此最先输出。

1.6 Promise.reject(reason)

返回一个新的 Promise 实例，该实例的状态为rejected。

const p = Promise.reject('出错了');
// 等同于
const p = new Promise((resolve, reject) => reject('出错了'))

p.then(null, function (s) {
  console.log(s)
});
// 出错了

实例p，状态为rejected，回调函数会立即执行。

注意， Promise.reject()方法的参数，会原封不动地作为reject的理由，变成后续方法的参数。 这一点与Promise.resolve方法不一致。

const thenable = {
  then(resolve, reject) {
    reject('出错了');
  }
};

Promise.reject(thenable)
.catch(e => {
  console.log(e === thenable)
})
// true
上面代码中，Promise.reject方法的参数是一个thenable对象，
执行以后，后面catch方法的参数不是reject抛出的“出错了”这个字符串，
而是thenable对象。

Promise