异步编程（1）：Promise

咱们都知道，ES是单线程语言。因此异步编程对它来讲，尤为重要。也能够说是他的核心功能。

咱们常见的异步编程有不少，好比 回调函数​、事件监听 发布订阅 Promise等。

在早期的时候，咱们使用的主要方式是回调函数，可是当咱们有不少回调函数须要依赖的时候，一层套一层，就会造成回调地狱。

回调地狱既不利于阅读也不利于维护，因此前辈先贤们为了解决这个问题，作了不少努力。其中Promise 就是其中的一种方案。

Promise

Promise 是一个构造函数，返回一个 promise 对象。该对象有三种状态，并且状态不可逆。还有then catch finally 等方法。网上有大量的基础方法定义，咱们就不在罗列了。

使用

then的链式调用

咱们知道，Promise支持链式调用，那假如中间状态变成rejected了，会怎么样呢。

let p1 = new Promise((resolve,reject) => {
    setTimeout( () => resolve(200) , 1000)
})

p1.then(() => {
        console.log(11)
    })
    .then(() => {
        throw Error(22)
    })
    .then( () => {
        console.log(33)
    })
    .catch(err => {
        console.log('this is error',err)
    })
// 11
// this is error 22
复制代码

当 then 的回调函数返回一个错误的时候，返回的是一个rejected`状态的promise。以后的链式调用被终止了，被最后的catch捕获到。

咱们知道then 实际上是能够接受两个回调函数的，咱们换一个方式猜下执行顺序是什么呢？

let p1 = new Promise((resolve,reject) => {
    setTimeout( () => resolve(200) , 1000)
})

p1.then(() => {
        console.log(11)
    })
    .then(() => {
        throw Error(22)
    })
    .then( () => {
        console.log(33)
    },fail => {
        console.log('this is from 3rd fn',fail)
    })
    .catch(err => {
        console.log('this is error',err)
    })
    
// 输出结果为：
//11
// this is from 3rd fn

复制代码

有没有想到这个结果。

从现象看：是由于前面已经处理了rejected 因此后面catch不会在处理了。

let p1 = new Promise((resolve,reject) => {
    setTimeout( () => resolve(200) , 1000)
})

p1.then(() => {
        console.log(11)
    })
    .then(() => {
        throw Error(22)
    })
    .then( () => {
        console.log(33)
    },fail => {
        console.log('this is from 3rd fn', fail)
    })
    .then( () => {
        console.log(44)
    })
    .catch(err => {
        console.log('this is error',err)
    })
    .then( () => {
        console.log(55)
    })
    
   
// 输出为：
// 11
// this is from 3rd fn 22
// 44
// 55
复制代码

怎么样，有没有想到，处理错误以后，还能继续执行，哪怕在catch后面也能执行。

透过现象看本质，下面咱们对上面几种状况用一个统一的解释来理解下。

• 首先咱们要知道 then 方法，他接受两个回调，一个处理 fulilled 状态， 一个处理 rejected状态。每次都返回一个新的promise 对象。

• catch的本质是obj.then(undefined, onRejected)。

因此上面的几种状况也就好理解了：

then 和 catch 都会返回一个promise 对象。当中间有状态变为rejected以后，他会一直往下寻找，找到最近的rejected状态处理函数，以后根据处理函数的返回值继续返回不一样状态的promise对象。一直执行到链式调用的最后。

因此咱们在使用的时候要注意了，避免没必要要的麻烦。通常用catch 来处理，而且放到最后。这样能统一处理。

几个常见题型

let p1 = new Promise((resolve, reject) => {
    console.log(11)
    resolve()
    console.log(22)
  })
  p1.then(() => {
    console.log(33)
  })
  console.log(44)

// 结果为： 11 、22 、4四、33
复制代码

解释：Promise构造函数会当即执行，因此先是十一、resolve、22，因为then是异步的，因此代码紧接着是4四、最后才是33

Promise.resolve(11)
  .then(22)
  .then(Promise.resolve(33))
  .then(console.log)

// 输出 11
复制代码

解释：then 参数不是function的时候都会被忽略。

使用场景

下面咱们来看一下，它的一些经常使用场景：

一、异步b依赖异步a

// 异步请求b 依赖异步请求a
let p1 = new Promise(function(resolve,reject){
  $.post(urla,data,function(res){
    resolve(res);
  })
})

p1.then(function(res){
  $.post(urlb,data,function(){
    // 处理请求返回后的数据
  })
})
复制代码

二、依赖异步a和异步b

咱们有时候常常会遇到这样的一种场景，咱们须要发起两个互不依赖异步请求，而后等待两个请求都返回以后再处理。

let p1 = new Promise((resolve,reject) =>{
    setTimeout( () => resolve(100), 200)
})

let p2 = new Promise((resolve,reject) =>{
    setTimeout( () => reject(200), 300)
})

Promise.all([p1,p2])
    .then(values =>{
        console.log(values);		// [100,200]
    },fail => {
        console.log(fail)
    })
复制代码

all方法返回的是一个promise对象，因此他也有 then catch 等方法。

但愿上面一点点内容，可以帮助你们加深理解。若有错误，不吝指正。

参考连接：

developer.mozilla.org/zh-CN/docs/…