JS Promise 从入门到实践（转载）

原作者：ER_PM
原链接：https://www.jianshu.com/p/2eda5d788bb6
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

如果我们不是把头埋在沙子里，而是准备好应对之道的话，未来会美好得多。

ES6 新增的promise，能让你书写简单的异步代码，为什么要异步呢？使用异步代码的原因在于不希望在执行长时间任务的时候，应用程序的执行被阻塞(程序执行完前，无法继续别的操作)，影响用户体验。

image

promise对象的含义

promise中文的含义是承诺，在JS里新建一个promise(承诺),会发生两件事情，一个是兑现承诺，一个是违背承诺，调用它内置的then方法，接收两个回调函数，一个成功回调函数(resolve)和一个失败回调(reject)，当承诺成功兑现就调用resolve函数，当出现错误异常(承诺被拒绝)就调用reject函数。

来看个兑现承诺的例子，直观感受下它：

//通过构造函数创建promise
const promise = new Promise((resolve, reject) => {
   resolve("承诺被兑现"); //手动调用
   // reject('承诺被拒绝');
});
promise.then(resolve => {
   console.log(resolve);
}, err => {
   console.log(err);
});
//打印"承诺被兑现"

promise的生命周期

promise，它代表了一个我们暂时还没获得但在未来有希望获得的值，一个promise对象的整个生命周期中，它会经历多种状态:
1、promise对象被创建；
2、promise进入等待状态(也称为未实现unresolved状态)；
3、在程序执行过程中，如果promise的resolve函数被调用，promise就会进入完成状态，然后在该状态下我们能够获取到承诺的值。另一种情况，如果promise的reject函数被调用，或者一个未处理的异常在promise调用过程中发生了，promise就会进入到拒绝状态，能让我们知道被拒绝的原因，一旦某个promise进入完成状态或者拒绝状态，它的使命就完成了。

拒绝promise

拒绝promise有两种方式，一种是显式拒绝，另一种是隐式拒绝。显示拒绝就是我们在promise的执行函数里调用reject方法；隐式拒绝，就是在处理promise过程中抛出一个异常。

显示拒绝：

const promise = new Promise((resolve, reject) => {
   reject('承诺被拒绝');
});
promise.then(resolve => {
   console.log(resolve);
}, err => {
   console.log(err);
});
//打印"承诺被拒绝"

隐式拒绝：

看下面的程序，通过在then方法后面链式调用catch方法，同样可以在promise进入被拒绝状态时提供错误回调函数。

const promise = new Promise((resolve, reject) => {
    ++undefineVariable; //一个未声明的变量
});

promise.then(resolve => {
  console.log(resolve);
}).catch(() => {
  console.log("出现异常，承诺被拒绝");
});
//打印 "出现异常，承诺被拒绝"

在程序里我们操作了未声明的undefineVariable变量，程序抛出了一个异常，由于执行函数中没有try-catch语句，所以当前的promise被隐式拒绝了，catch回调函数最后被调用了。

对比显示拒绝和隐式拒绝它们二者的作用都是相同的，隐式拒绝更加简洁方便，假设有多个promise，为每个promise都写一遍reject方法是非常乏味的。所以使用后者的话，只要发生了异常，所有的错误和拒绝原因都会在catch回调函数中被定位。

链式调用promise

特工Alice，需挑战3个高难度挑战，需依次完成A、B、C任务，全部任务通过则加入X特工队，其中一个任务失败，则被淘汰出局。

let challenge = (task) => {
   return new Promise((resolve, reject) => {
     resolve("恭喜Alice通过 " + task + " 任务!");
   });
 };

challenge("A").then((passTask) => {
  console.log(passTask);
  return challenge("B");
}).then(passTask => {
   console.log(passTask);
   return challenge("C");
}).then((passTask) => {
   console.log(passTask + " 您已顺利完成所有任务，欢迎您加入X特工队。");
}).catch(() => console.log("挑战失败，Alice被淘汰出局"));

//控制台依次打印：
//"恭喜Alice通过 A 任务!"
//"恭喜Alice通过 B 任务!"
//"恭喜Alice通过 C 任务! 您已顺利完成所有任务，欢迎您加入X特工队。"

promise.all 多个并行

上面的特工任务是相互依赖的，是一连串的按顺序的异步代码，同时promise也支持等待多个相互独立的异步任务。让我们在来看一个并行执行的例子。

Bob和Sansa是一对恩爱夫妻，两人非常喜欢在一起做饭，周六是两人的结婚纪念日，所以他们计划做一顿烂漫的烛光晚餐来庆祝这美好的一天。他倆相互约定，Bob负责买花、浪漫的装饰、美丽的贴纸来装饰大厅，还有蜡烛、红酒等，Sansa负责菜肴制作，分工好后，他们马上就忙碌了起来……

let makeCandlelightDinner = (task) => {
  return new Promise((resolve, reject) => {
    resolve(task);
  });
};

Promise.all([
  makeCandlelightDinner("菜肴"),
  makeCandlelightDinner("蜡烛"),
  makeCandlelightDinner("美酒"),
]).then(candlelightDinner => {
  let dishes = candlelightDinner[0]; //菜肴
  let candle = candlelightDinner[1];//蜡烛
  let fineWine = candlelightDinner[2]; //美酒

  if (dishes != undefined || candle != undefined || fineWine != undefined) {
    console.log("Bob和Sansa一起制作完成了烛光晚餐的材料，分别有：" + dishes + "、" + candle + "、" + fineWine + "。");
  }

}).catch(error => console.log("烛光晚餐制作失败，也许Bob过于兴奋，突发心脏病晕倒了！"));

//控制台打印："Bob和Sansa一起制作完成了烛光晚餐的材料，分别有：菜肴、蜡烛、美酒。"

Bob和Sansa的烛光晚餐制作，如你所见，我们不必关心任务的执行顺序，通过方法Promise.all可以等待多个promise，这个方法将一个promise数组作为参数，然后创建一个新的promise对象，一旦数组中的promise全部被解决，这个返回的promise就会被解决，而一旦其中一个promise失败了，那么整个新promise对象也会被拒绝。

后续的回调函数接收成功值组成的数组，数组中的每一项都对应promise数组中的对应项。

Promise.race 竞赛

假设我们可以支配一支特工队，我们希望第一个响应命令的"特工"分配一个任务，我们可以书写这样类似的代码：

let getAgent = (agent) => {
  return new Promise((resolve, reject) => {
    //设置一个0 到 2s之间的定时器
    setTimeout(() => {
      resolve(agent);
    }, Math.floor(Math.random() * 2000));
  });
};
Promise.race([
  getAgent("Bob"),
  getAgent("Alice"),
  getAgent("Joue")
]).then(agent => {
  if (agent != undefined) {
    console.log(agent + " 是第一位响应命令的特工！");
  }
}).catch(error => console.log('命令无人接收！'));
//打印："Alice 是第一位响应命令的特工！" 注意：这是随机打印的

promise.race方法传入一个promise数组会返回一个全新的promise对象，一旦数组中某一个promise被第一处理兑现或被拒绝，这个返回的promise就同样会被处理或被拒绝。

面向未来的async函数

特工Alice，需挑战3个高难度挑战，需依次完成A、B、C任务，全部任务通过则加入X特工队，其中一个任务失败，则被淘汰出局。

async和await是ES7新增的关键字，能让你书写更优雅的异步函数，通过下面的代码相信你能看的出来，

let challenge = (task) => {
  return new Promise((resolve, reject) => {
    //每个任务完成的时间不一
    setTimeout(() => {
      resolve(task);
    }, Math.floor(Math.random() * 2000));

  });
}
(async function () {
  try {
    const aTask = await challenge("A");
    const bTask = await challenge("B");
    const cTask = await challenge("C");
    console.log(`Alice顺利完成 ${aTask}，${bTask}，${cTask}任务。`);
  } catch (e) {
    console.log(e);
  }
})();
//控制台打印："Alice顺利完成 A，B，C任务。"

通过在关键字function之前使用关键字async关键字，可以表明当前的函数依赖一个异步返回的值，在每个调用异步任务位置上，都要放置一个await关键字，用来告诉JavaScript引擎，请在不阻塞应用执行的情况下在这个位置上等待执行结果。

最后promise异步编程就告一段落了，你掌握了吗？