一、 基础概念

1、 Promise对象是一个构造函数，用来生成promise实例；是异步编程的一种解决方案。
下面创造一个Promise实例：

const promise = new Promise(function(resolve, reject) {
  // ... some code
  if (/* 异步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});

Promise构造函数接受一个函数作为参数，该函数的两个参数分别是resolve和reject。它们是两个函数，由 JavaScript 引擎提供，不用自己部署。

二、 Promise.prototype.then()

Promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数。（Promise对象的状态一旦生成就不会改变）

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

then方法可以接受两个回调函数作为参数。其中，第二个函数是可选的，不一定要提供。这两个函数都接受Promise对象传出的值作为参数。then方法返回的是一个实例（不是原来那个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.prototype.catch()

1、 Promise.prototype.catch方法用于指定发生错误时的回调函数。

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

getJSON方法返回一个 Promise 对象，如果该对象状态变为resolved，则会调用then方法指定的回调函数；如果异步操作抛出错误，状态就会变为rejected，就会调用catch方法指定的回调函数，处理这个错误。另外，then方法指定的回调函数，如果运行中抛出错误，也会被catch方法捕获。
2、一般来说，不要在then方法里面定义 Reject 状态的回调函数（即then的第二个参数），最好使用catch方法。

// bad
promise
  .then(function(data) {
    // success
  }, function(err) {
    // error
  });

// good
promise
  .then(function(data) { //cb
    // success
  })
  .catch(function(err) {
    // error
  });

Promise 对象后面要跟catch方法，这样可以处理 Promise 内部发生的错误。catch方法返回的还是一个 Promise 对象，因此后面还可以接着调用then方法。

四、Promise.prototype.finally()

1、 finally方法用于指定不管前面Promise对象状态如何，都会执行的操作。

promise
.then(result => {···})
.catch(error => {···})
.finally(() => {···})

上面代码中，不管promise最后的状态，在执行完then或catch指定的回调函数以后，都会执行finally方法指定的回调函数。
finally方法的回调函数不接受任何参数，它与Promise对象状态无关，不依赖于 Promise 的执行结果。

五、Promise.all()

1、all方法将多个Promise实例，组成一个新的Promise实例。
const p = Promise.all([p1,p2,p3])
Promise.all()接受一个数组为参数，p1,p2,p3都是Promise实例；如果其中有不是Promise实例的，那么会先调用Promise.resolve方法，将它变成实例，再进行下一步处理；
①只有p1,p2,p3的状态都是fulfilled，p的状态才会变成fulfilled，此时p1,p2,p3的返回值组成一个数组，传递给p的回调函数；
②如果p1,p2,p3之中有一个被rejected，那么p的状态就会变成rejected，此时第一个被rejected的实例的返回值，传递给p的回调函数；

// 生成一个Promise对象的数组
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){
  // ...
})

六、Promise.race()

1、 Promise.race方法同样是将多个 Promise 实例，包装成一个新的 Promise 实例；
const p = Promise.all([p1,p2,p3])
当p1,p2,p3之中有一个实例率先改变状态，那么p的状态就根着改变，将那个实例的返回值，传递给p的回调函数；

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)

上面代码中，如果 5 秒之内fetch方法无法返回结果，变量p的状态就会变为rejected，从而触发catch方法指定的回调函数。

七、Promise.resolve()

1、 有时需要将现有对象转化成Promise实例，状态为resolved，那么就要用到Promise.resolve()方法

Promise.resolve('foo')
// 等价于
new Promise(resolve => resolve('foo'))

八、Promise.reject()

• Promise.reject()也会返回一个Promise实例，状态为rejected

//Promise.resolve()
const b = {
  way(resolve,reject){
    resolve('你对了')
  }
}
Promise.resolve(b).then((e)=>{
  console.log(e)
  console.log(e === b)
})

//Promise.reject()
const a = {
  nct(resolve,reject){
    reject('你错了')
  }
}
Promise.reject(a).catch((e)=>{
  console.log(e)
  console.log(e === a)
})

image.png