Promise是什么？

Promise是一个代理对象，代理一个值，代表这个值的未来结果（异步操作的结果）。当未来发生时，Promise的状态会发生改变，同时调用我们注册在不同情况下的回调方法。

在整个过程中实际上涉及到两个角色，我们可以管他们一个叫Promise的请求方，一个叫Promise的提供方。
这不难理解，请求方就是请求那个未来结果的一方，提供方就是接受了这个请求，并且承诺如果未来的结果取回来了，或者发生了什么意外，都会通知请求方的这一方。 那么这个承诺，就是我们今天要说的Promise对象。

说说提供方

提供方通过如下语法提供承诺（Promise的一个实例对象）

new Promise((resolve, reject) => {
    //...  数据请求过程中
    if(请求成功){
        resolve(数据);
    }else{
        reject(失败原因);
    }
})

一个 Promise有以下几种状态:

• pending: 初始状态，既不是成功，也不是失败状态。
• fulfilled: 意味着操作成功完成。
• rejected: 意味着操作失败。

上面的代码返回Promise实例的时候，这个实例就是初始状态（pending）。

Promise对象创建时，参数是一个函数，我们叫它executor，MDN上是这样解释executor的：

executor是带有 resolve 和 reject 两个参数的函数 。Promise构造函数执行时立即调用executor 函数， resolve 和 reject 两个函数作为参数传递给executor（executor 函数在Promise构造函数返回所建promise实例对象前被调用）。resolve 和 reject 函数被调用时，分别将promise的状态改为fulfilled（完成）或rejected（失败）。executor 内部通常会执行一些异步操作，一旦异步操作执行完毕(可能成功/失败)，要么调用resolve函数来将promise状态改成fulfilled，要么调用reject 函数将promise的状态改为rejected。如果在executor函数中抛出一个错误，那么该promise 状态为rejected。executor函数的返回值被忽略。

这样解释过后，我们其实就很清楚的知道，在数据请求结束后，提供方通过调用resolve或者reject来改变promise的状态，然后通知请求方，这时提供方就完成了自己的任务。

说说请求方

我们上面说到提供方返回了一个pending状态的Promise实例，pending状态的实例提供了then方法，让请求方可以为请求成功或者失败都传入响应的处理函数。
then方法具体语法如下：

promise.then(onFulfilled [, onRejected]);

promise.then(value => {
  // fulfillment: 成功相关的逻辑
}, reason => {
  // rejection: 失败相关的原因和逻辑
});

then方法包含两个参数：onFulfilled 和 onRejected，它们都是 Function 类型。当Promise状态为fulfilled时，调用 then 的 onFulfilled 方法，当Promise状态为rejected时，调用 then 的 onRejected 方法。

说到这里其实大致上基本已经清楚了，我们简单概括一下：Promise是提供方提供的一个值的代理，在请求成功或者失败后，会调用请求方在对应时机上绑定的处理函数。

一些其他的方法

下面对方法的解释和样例代码，为了权威起见，基本都来自MDN，但是MDN上的Promise.allSettled()写错了，写成了Promise.prototype.allSettled()，我已经提交了pull request，但是如果还没有改过来，请大家参考本文中的内容，不要被错误误导。

Promise.prototype.catch()

catch() 方法返回一个Promise，并且处理拒绝的情况。它的行为与调用Promise.prototype.then(undefined, onRejected)then() 方法相同。 (事实上, 调用 obj.catch(onRejected) 的时候，内部就是转化成了调用 obj.then(undefined, onRejected)).

Promise.prototype.finally()

finally() 方法返回一个Promise。在promise结束时，无论结果是fulfilled或者是rejected，都会执行指定的回调函数。这为在Promise是否成功完成后都需要执行的代码提供了一种方式。

这避免了同样的语句需要在then()和catch()中各写一次的情况。
对java异常处理有了解的话，应该不难理解。

Promise.all()

Promise.all(iterable) 方法返回一个 Promise实例，此实例在 iterable 参数内所有的 promise 都“完成（resolved）”或参数中不包含 promise 时回调完成（resolve）；如果参数中 promise 有一个失败（rejected），此实例回调失败（reject），失败原因的是第一个失败 promise 的结果。
一般用来处理没有先后顺序的多个异步请求。

代码样例：

var promise1 = Promise.resolve(3);
var promise2 = 42;
var promise3 = new Promise(function(resolve, reject) {
  setTimeout(resolve, 100, 'foo');
});

Promise.all([promise1, promise2, promise3]).then(function(values) {
  console.log(values);
});
// expected output: Array [3, 42, "foo"]

Promise.allSettled()

方法返回一个在所有给定的promise已被决议或被拒绝后决议的promise，并带有一个对象数组，每个对象表示对应的promise结果。

代码样例：

const promise1 = Promise.resolve(3);
const promise2 = new Promise((resolve, reject) => setTimeout(reject, 100, 'foo'));
const promises = [promise1, promise2];

Promise.allSettled(promises).
  then((results) => results.forEach((result) => console.log(result.status)));

// expected output:
// "fulfilled"
// "rejected"

Promise.race()

方法返回一个 promise，一旦迭代器中的某个promise解决或拒绝，返回的 promise就会解决或拒绝。

样例代码：

var promise1 = new Promise(function(resolve, reject) {
    setTimeout(resolve, 500, 'one');
});

var promise2 = new Promise(function(resolve, reject) {
    setTimeout(resolve, 100, 'two');
});

Promise.race([promise1, promise2]).then(function(value) {
  console.log(value);
  // Both resolve, but promise2 is faster
});
// expected output: "two"

Promise.resolve()

方法返回一个以给定值解析后的Promise对象，可以简单理解成一个被调用了resolve方法，状态变成了fulfilled的Promise对象

样例代码：

var promise1 = Promise.resolve(123);

promise1.then(function(value) {
  console.log(value);
  // expected output: 123
});

Promise.reject()

方法返回一个带有拒绝原因的Promise对象。可以简单理解成一个被调用了reject方法，状态变成了rejected的Promise对象

样例代码：

function resolved(result) {
  console.log('Resolved');
}

function rejected(result) {
  console.error(result);
}

Promise.reject(new Error('fail')).then(resolved, rejected);
// expected output: Error: fail