前言

作者：ssh，来源：前端从进阶到入院，如果让你手写async函数的实现，你是不是会觉得很复杂？这篇文章带你用20行搞定它的核心。

经常有人说async函数是generator函数的语法糖，那么到底是怎么样一个糖呢？让我们来一层层的剥开它的糖衣。

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

这篇文章的目的就是带大家理解清楚async和generator之间到底是如何相互协作，管理异步的。

示例

  1. const getData = () => new Promise(resolve => setTimeout(() => resolve("data"), 1000))
  2. async function test() {
  3.   const data = await getData()
  4.   console.log('data: ', data);
  5.   const data2 = await getData()
  6.   console.log('data2: ', data2);
  7.   return 'success'
  8. }
  9. // 这样的一个函数 应该再1秒后打印data 再过一秒打印data2 最后打印success
  10. test().then(res => console.log(res))

思路

对于这个简单的案例来说，如果我们把它用generator函数表达，会是怎么样的呢？

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的位置。
利用这个特性，我们只要编写一个自动执行的函数，就可以让这个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))

那么大体上的思路已经确定了，
asyncToGenerator接受一个generator函数，返回一个promise，
关键就在于，里面用yield来划分的异步流程，应该如何自动执行。

如果是手动执行

在编写这个函数之前，我们先模拟手动去调用这个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的值会被确定呢？

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

function* testG() {
  // await被编译成了yield
  const data = yield getData()
  console.log('data: ', data);
  const data2 = yield getData()
  console.log('data2: ', data2);
  return 'success'
}
const res = testG()
const step1 = res.next()
step1.value.then(e => {
  console.log("e:",e)
  // const step2 = res.next()
})

注释掉打印
image.png
放开注释打印
image.png

下一次调用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.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") // 递归一直走到done
      })
    }
}

不多不少，22行。