手写async,await

文章来源：手写async await的最简实现（20行） (opens new window)

前置知识：JavaScript中的迭代及相关问题

async/await示例

const getData = (data) => new Promise((resolve) => setTimeout(resolve, 2000, data + 1));

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

// 2秒后打印value1:  2，再过2秒打印value2:  3，最后打印success
test().then((res) => console.log(res));

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

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

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

利用这个特性，我们只要编写一个自动执行的函数，就可以让这个generator函数完全实现async函数的功能。

const getData = (data) => new Promise((resolve) => setTimeout(resolve, 2000, data + 1));

const test = asyncToGenerator(
  function* testG() {
    // await被编译成了yield
    const value1 = yield getData(1);
    console.log('value1: ', value1);
    const value2 = yield getData(value1);
    console.log('value2: ', value2);
    return 'success';
  },
);

test().then((res) => console.log(res));

那么大体上的思路已经确定了：

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

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

如果是手动执行

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

function* testG() {
  const value1 = yield getData(1);
  console.log('value1: ', value1);
  const value2 = yield getData(value1);
  console.log('value2: ', value2);
  return 'success';
}

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

// 返回了一个迭代器
const gen = testG();

然后开始执行第一次next

// 第一次调用next 停留在第一个yield的位置
// 返回的promise里 包含了value1需要的数据
const valuePromise = gen.next();

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

const value1 = yield getData(1);

这段代码要切割成左右两部分来看，第一次调用next，其实只是停留在了yield getData(1)这里，value1的值并没有被确定。

那么什么时候value1的值会被确定呢？

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

也就是说，我们再次调用gen.next('这个参数才会被赋给value1变量')的时候，value1的值才会被确定为'这个参数才会被赋给value1变量'

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

// 然后这里的value1才有值
const value1 = yield getData(1)

// 然后打印出value1
console.log('value1: ', value1);

// 然后继续走到下一个yield
const value2 = yield getData(value1)

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

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

借助这个特性，如果我们这样去控制yield的流程，是不是就能实现异步串行了？

function* testG() {
  const value1 = yield getData(1);
  console.log('value1: ', value1);
  const value2 = yield getData(value1);
  console.log('value2: ', value2);
  return 'success';
}

const gen = testG();

const valuePromise = gen.next();

valuePromise.then((value1) => {
  // value1的value被拿到了 继续调用next并且传递给value1
  const value2Promise = gen.next(value1);

  // console.log('value1: ', value1);
  // 此时就会打印出value1为2

  value2Promise.value.then((value2) => {
    // value2的value拿到了 继续调用next并且传递value2
    gen.next(value2);

    // console.log('value2: ', value2);
    // 此时就会打印出value2为3
  });
});

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

最终实现

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

    // 返回一个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);
        }
        // 除了最后结束的时候外，每次调用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就开始执行了
          //    })
          // })
          (val) => {
            step('next', val);
          },
          // 如果promise被reject了 就再次进入step函数
          // 不同的是，这次的try catch中调用的是gen.throw(err)
          // 那么自然就被catch到 然后把promise给reject掉啦
          // Generator.prototype.throw() 向生成器抛出一个错误
          (err) => {
            step('throw', err);
          },
        );
      }
      step('next');
    });
  };
}

使用

const test = asyncToGenerator(testG);
test().then((res) => console.log(res));