手写async await的最简实现（20行）

前言

若是让你手写async函数的实现，你是否是会以为很复杂？这篇文章带你用20行搞定它的核心。javascript

常常有人说async函数是generator函数的语法糖，那么究竟是怎么样一个糖呢？让咱们来一层层的剥开它的糖衣。前端

有的同窗想说，既然用了generator函数何须还要实现async呢？java

这篇文章的目的就是带你们理解清楚async和generator之间究竟是如何相互协做，管理异步的。git

示例

const getData = () => new Promise(resolve => setTimeout(() => resolve("data"), 1000))

async function test() {
  const data = await getData()
  console.log('data: ', data);
  const data2 = await getData()
  console.log('data2: ', data2);
  return 'success'
}

// 这样的一个函数 应该再1秒后打印data 再过一秒打印data2 最后打印success
test().then(res => console.log(res))
复制代码

思路

对于这个简单的案例来讲，若是咱们把它用generator函数表达，会是怎么样的呢？github

function* testG() {
  // await被编译成了yield
  const data = yield getData()
  console.log('data: ', data);
  const data2 = yield getData()
  console.log('data2: ', data2);
  return 'success'
}
复制代码

咱们知道，generator函数是不会自动执行的，每一次调用它的next方法，会停留在下一个yield的位置。promise

利用这个特性，咱们只要编写一个自动执行的函数，就可让这个generator函数彻底实现async函数的功能。浏览器

const getData = () => new Promise(resolve => setTimeout(() => resolve("data"), 1000))
  
var test = asyncToGenerator(
    function* testG() {
      // await被编译成了yield
      const data = yield getData()
      console.log('data: ', data);
      const data2 = yield getData()
      console.log('data2: ', data2);
      return 'success'
    }
)

test().then(res => console.log(res))
复制代码

那么大致上的思路已经肯定了，babel

asyncToGenerator接受一个generator函数，返回一个promise，markdown

关键就在于，里面用yield来划分的异步流程，应该如何自动执行。app

若是是手动执行

在编写这个函数以前，咱们先模拟手动去调用这个generator函数去一步步的把流程走完，有助于后面的思考。

function* testG() {
  // await被编译成了yield
  const data = yield getData()
  console.log('data: ', data);
  const data2 = yield getData()
  console.log('data2: ', data2);
  return 'success'
}
复制代码

咱们先调用testG生成一个迭代器

// 返回了一个迭代器
var gen = testG()
复制代码

而后开始执行第一次next

// 第一次调用next 停留在第一个yield的位置
// 返回的promise里 包含了data须要的数据
var dataPromise = gen.next()
复制代码

这里返回了一个promise，就是第一次getData()所返回的promise，注意

const data = yield getData()
复制代码

这段代码要切割成左右两部分来看，第一次调用next，其实只是停留在了yield getData()这里，

data的值并无被肯定。

那么何时data的值会被肯定呢？

下一次调用next的时候，传的参数会被做为上一个yield前面接受的值

也就是说，咱们再次调用gen.next('这个参数才会被赋给data变量')的时候

data的值才会被肯定为'这个参数才会被赋给data变量'

gen.next('这个参数才会被赋给data变量')

// 而后这里的data才有值
const data = yield getData()

// 而后打印出data
console.log('data: ', data);

// 而后继续走到下一个yield
const data2 = yield getData()
复制代码

而后往下执行，直到遇到下一个yield，继续这样的流程...

这是generator函数设计的一个比较难理解的点，可是为了实现咱们的目标，仍是得去学习它~

借助这个特性，若是咱们这样去控制yield的流程，是否是就能实现异步串行了？

function* testG() {
  // await被编译成了yield
  const data = yield getData()
  console.log('data: ', data);
  const data2 = yield getData()
  console.log('data2: ', data2);
  return 'success'
}

var gen = testG()

var dataPromise = gen.next()

dataPromise.then((value1) => {
    // data1的value被拿到了 继续调用next而且传递给data
    var data2Promise = gen.next(value1)
    
    // console.log('data: ', data);
    // 此时就会打印出data
    
    data2Promise.value.then((value2) => {
        // data2的value拿到了 继续调用next而且传递value2
         gen.next(value2)
         
        // console.log('data2: ', data2);
        // 此时就会打印出data2
    })
})
复制代码

这样的一个看着像callback hell的调用，就可让咱们的generator函数把异步安排的明明白白。

实现

有了这样的思路，实现这个高阶函数就变得很简单了。

先总体看一下结构，有个印象，而后咱们逐行注释讲解。

function asyncToGenerator(generatorFunc) {
    return function() {
      const gen = generatorFunc.apply(this, arguments)
      return new Promise((resolve, reject) => {
        function step(key, arg) {
          let generatorResult
          try {
            generatorResult = gen[key](arg)
          } catch (error) {
            return reject(error)
          }
          const { value, done } = generatorResult
          if (done) {
            return resolve(value)
          } else {
            return Promise.resolve(value).then(val => step('next', val), err => step('throw', err))
          }
        }
        step("next")
      })
    }
}
复制代码

很少很多，22行。

接下来逐行讲解。

function asyncToGenerator(generatorFunc) {
  // 返回的是一个新的函数
  return function() {
  
    // 先调用generator函数 生成迭代器
    // 对应 var gen = testG()
    const gen = generatorFunc.apply(this, arguments)

    // 返回一个promise 由于外部是用.then的方式 或者await的方式去使用这个函数的返回值的
    // var test = asyncToGenerator(testG)
    // test().then(res => console.log(res))
    return new Promise((resolve, reject) => {
    
      // 内部定义一个step函数 用来一步一步的跨过yield的阻碍
      // key有next和throw两种取值，分别对应了gen的next和throw方法
      // arg参数则是用来把promise resolve出来的值交给下一个yield
      function step(key, arg) {
        let generatorResult
        
        // 这个方法须要包裹在try catch中
        // 若是报错了 就把promise给reject掉 外部经过.catch能够获取到错误
        try {
          generatorResult = gen[key](arg)
        } catch (error) {
          return reject(error)
        }

        // gen.next() 获得的结果是一个 { value, done } 的结构
        const { value, done } = generatorResult

        if (done) {
          // 若是已经完成了 就直接resolve这个promise
          // 这个done是在最后一次调用next后才会为true
          // 以本文的例子来讲 此时的结果是 { done: true, value: 'success' }
          // 这个value也就是generator函数最后的返回值
          return resolve(value)
        } else {
          // 除了最后结束的时候外，每次调用gen.next()
          // 实际上是返回 { value: Promise, done: false } 的结构，
          // 这里要注意的是Promise.resolve能够接受一个promise为参数
          // 而且这个promise参数被resolve的时候，这个then才会被调用
          return Promise.resolve(
            // 这个value对应的是yield后面的promise
            value
          ).then(
            // value这个promise被resove的时候，就会执行next
            // 而且只要done不是true的时候 就会递归的往下解开promise
            // 对应gen.next().value.then(value => {
            // gen.next(value).value.then(value2 => {
            // gen.next() 
            //
            // // 此时done为true了 整个promise被resolve了 
            // // 最外部的test().then(res => console.log(res))的then就开始执行了
            // })
            // })
            function onResolve(val) {
              step("next", val)
            },
            // 若是promise被reject了 就再次进入step函数
            // 不一样的是，此次的try catch中调用的是gen.throw(err)
            // 那么天然就被catch到 而后把promise给reject掉啦
            function onReject(err) {
              step("throw", err)
            },
          )
        }
      }
      step("next")
    })
  }
}
复制代码

源码地址

这个 js文件的代码能够直接放进浏览器里运行，欢迎调戏。

总结

本文用最简单的方式实现了asyncToGenerator这个函数，这是babel编译async函数的核心，固然在babel中，generator函数也被编译成了一个很原始的形式，本文咱们直接以generator替代。

这也是实现promise串行的一个很棒的模式，若是本篇文章对你有帮助，点个赞就好啦。

❤️感谢你们

1.若是本文对你有帮助，就点个赞支持下吧，你的「赞」是我创做的动力。

2.关注公众号前端从进阶到入院！不按期推送高质量原创文章哦。