ES6（十五）Promise对象

---

前言

ES6针对异步功能的实现提出了Promise这一个新的对象，使用Promise可以写出更加优雅的异步代码，避免回调地狱的产生。

Promise的含义

• Promise，简单说就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果。从语法上说，Promise 是一个对象，从它可以获取异步操作的消息。Promise 提供统一的 API，各种异步操作都可以用同样的方法进行处理。

  缺点

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

基本用法

resolve() reject()函数

const promise = new Promise(function(resolve, reject) {
  // ... some code

  if (/* 异步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});
// 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.prototype.then()/cath()

then方法的第一个参数是resolved状态的回调函数，第二个参数是rejected状态的回调函数，它们都是可选的。

const promise = new Promise(function(resolve, reject) {
  resolve('ok'); // 状态已经变成了 resolved 
  throw new Error('test'); // 不会再改变！！！！！！！！！
});
promise
  .then(function(value) { console.log(value) })
  .catch(function(error) { console.log(error) });
// ok

Promise 在resolve语句后面，再抛出错误，不会被捕获，等于没有抛出。因为 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捕捉错误，仍是会报错，因为setTimeout抛出来的错误是再promise函数体外？

catch方法用于捕捉所有中途发生的错误，即所有发生的错误最终都会在catch里面来进行处理。

Promise.prototype.finally()

finally()方法用于指定不管 Promise 对象最后状态如何，都会执行的操作。该方法是 ES2018 引入标准的。

finally方法的回调函数不接受任何参数，这意味着没有办法知道，前面的 Promise 状态到底是fulfilled还是rejected。这表明，finally方法里面的操作，应该是与状态无关的，不依赖于 Promise 的执行结果。

Promise.all()

Promise.all()方法用于将多个 Promise 实例，包装成一个新的 Promise 实例

Promise.all()方法的参数可以不是数组，但必须具有 Iterator 接口，且返回的每个成员都是 Promise 实例，不是的话会转为Promise实例

注意，如果作为参数的 Promise 实例，自己定义了catch方法，那么它一旦被rejected，并不会触发Promise.all()的catch方法，如果未定义则调用all的catch方法

all的状态判定的判定方法为 取交集？即只要有一个为rejected则为rejected

const databasePromise = connectDatabase();

const booksPromise = databasePromise
  .then(findAllBooks);

const userPromise = databasePromise
  .then(getCurrentUser);

Promise.all([
  booksPromise,
  userPromise
])
.then(([books, user]) => pickTopRecommendations(books, user));

Promise.race()

Promise.race()方法同样是将多个 Promise 实例，包装成一个新的 Promise 实例。

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

Promise.race()方法的参数与Promise.all()方法一样，如果不是 Promise 实例，就会先调用下面讲到的Promise.resolve()方法，将参数转为 Promise 实例，再进一步处理。

• 这个方法可以用来指定时间没有获取结果的处理方式

  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.allSettled()

有时候，我们希望等到一组异步操作都结束了，不管每一个操作是成功还是失败，再进行下一步操作。但是，现有的 Promise 方法很难实现这个要求。

ES2020 引入了Promise.allSettled()方法，用来确定一组异步操作是否都结束了（不管成功或失败）。所以，它的名字叫做”Settled“，包含了”fulfilled“和”rejected“两种情况。

Promise.allSettled()方法接受一个数组作为参数，数组的每个成员都是一个 Promise 对象，并返回一个新的 Promise 对象。只有等到参数数组的所有 Promise 对象都发生状态变更（不管是fulfilled还是rejected），返回的 Promise 对象才会发生状态变更。

该方法返回的新的 Promise 实例，一旦发生状态变更，状态总是fulfilled，不会变成rejected。状态变成fulfilled后，它的回调函数会接收到一个数组作为参数，该数组的每个成员对应前面数组的每个 Promise 对象。

Promise.any()

ES2021 引入了Promise.any()方法。该方法接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例返回。

取并集？与前面的all相对？即只要有一个是resolve 则 any 就是 resolve

Promise.resolve()

有时需要将现有对象转为 Promise 对象，Promise.resolve()方法就起到这个作用。

Promise.resolve()方法的参数分成四种情况。

• 参数是一个 Promise 实例

  不做处理

• 参数是一个thenable对象

  thenable对象指的是具有then方法的对象，比如下面这个对象。

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

  Promise.resolve()方法会将这个对象转为 Promise 对象，然后就立即执行thenable对象的then()方法。所以状态就基本上立刻会改变？

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

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

• 不带有任何参数

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

  立即resolve()的 Promise 对象，是在本轮“事件循环”（event loop）的结束时执行，而不是在下一轮“事件循环”的开始时

  setTimeout(function () {
    console.log('three');
  }, 0);
  
  Promise.resolve().then(function () {
    console.log('two');
  });
  
  console.log('one');
  
  // one
  // two
  // three setTimeout()是在下一轮事件循环开始时执行
  

Promise.reject()

Promise.reject(reason)方法也会返回一个新的 Promise 实例，该实例的状态为rejected。与上面相对？

Promise.reject()方法的参数，会原封不动地作为reject的理由，变成后续方法的参数。

Promise.reject('出错了')
.catch(e => {
  console.log(e === '出错了')
})
// true

Promise.try()

实际开发中，经常遇到一种情况：不知道或者不想区分，函数f是同步函数还是异步操作，但是想用 Promise 来处理它。因为这样就不用区分异步操作，直接用then指定下一步 流程，用catch捕捉中途的错误，但是有一个缺点就是，如果要执行的是同步函数，该函数会在事件循环的末尾来执行，从而可能会出错

那么有没有一种方法，让同步函数同步执行，异步函数异步执行，并且让它们具有统一的 API 呢？回答是可以的，并且还有两种写法。

• async

  const f = () => console.log('now');
  (async () => f())();
  console.log('next');
  // now
  // next
  

• 使用new Promise()

  const f = () => console.log('now');
  (
    () => new Promise(
      resolve => resolve(f())
    )
  )();
  console.log('next');
  // now
  // next
  

另外，ES6还提出了Promise.try()用于专门解决这类问题，使代码变得更加优雅简洁

const f = () => console.log('now');
Promise.try(f);
console.log('next');
// now!!!!!!
// next

事实上，Promise.try就是模拟try代码块，就像promise.catch模拟的是catch代码块。使用Promise.try包装Promise对象可以使Promise中的同步代码异步代码都按照相应的方式来处理

---

总结

本文主要介绍了ES6为异步JS添加的Promise对象，以及其众多的实例方法。