Skip to content
大纲

手写 async/await 的实现

包含以下功能

  1. 手写 async/await 的实现
  2. 异步并发、串行、并行
  3. 并发控制
  4. 请求封装及异步控制

手写 async/await 的实现

来源: https://github.com/sisterAn/JavaScript-Algorithms/issues/56

await 内部实现了 generator,其实 await 就是 generator 加上 Promise 的语法糖,且内部实现了自动执行 generator。如果你熟悉 co 的话,其实自己就可以实现这样的语法糖。

js
/**
 * async/await 实现
 * @param {*} generatorFunc
 */
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 genResult

        // 这个方法需要包裹在try catch中
        // 如果报错了 就把promise给reject掉 外部通过.catch可以获取到错误
        try {
          genResult = gen[key](arg)
        } catch (error) {
          return reject(error)
        }

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

        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')
    })
  }
}

var getData = () =>
  new Promise((resolve) => setTimeout(() => resolve('data'), 1000))
function* testG() {
  const data = yield getData()
  console.log('data: ', data)
  const data2 = yield getData()
  console.log('data2: ', data2)
  return 'success'
}

var gen = asyncToGenerator(testG)
gen().then((res) => console.log(res))
js
function asyncToGen(genFunction) {
  return function (...args) {
    const gen = genFunction.apply(this, args)
    return new Promise((resolve, reject) => {
      function step(key, arg) {
        let genResult
        try {
          genResult = gen[key](arg)
        } catch (err) {
          return reject(err)
        }
        const { value, done } = genResult
        if (done) {
          return resolve(value)
        }
        return Promise.resolve(value).then(
          (val) => {
            step('next', val)
          },
          (err) => {
            step('throw', err)
          }
        )
      }
      step('next')
    })
  }
}

const getData = () =>
  new Promise((resolve) => setTimeout(() => resolve('data'), 1000))
function* testG() {
  const data = yield getData()
  console.log('data: ', data)
  const data2 = yield getData()
  console.log('data2: ', data2)
  return 'success'
}

const gen = asyncToGen(testG)
gen().then((res) => console.log(res))
js
// 本质是希望实现一个co函数

let delay = function (time, fnc) {
  setTimeout(() => {
    fnc(time)
  }, time)
}

let promisefy = (fn) => {
  return (...arg) => {
    return new Promise((resolve, reject) => {
      fn(...arg, (param) => {
        resolve(param)
      })
    })
  }
}

let delayP = promisefy(delay)

const gen = function* () {
  const ret1 = yield delayP(1000)
  console.log(ret1)
  const ret2 = yield delayP(2000)
  console.log(ret2)
}

// 阴间写法
const g = gen()
g.next().value.then((res1) => {
  g.next(res1).value.then((res2) => {
    //
  })
})

// 正常写法
function co(generator) {
  return new Promise((resolve, reject) => {
    const gen = generator()
    function next(...param) {
      let tmp = gen.next(...param)
      if (tmp.done) {
        resolve(tmp.value)
        return
      }
      tmp.value.then((...ret) => {
        next(...ret)
      })
    }
    next()
  })
}

co(gen).then((res) => {
  console.log(res)
})
js
// 基于前面的测试用例实现一个简单版的(代码可以复制运行)
// - 本质上是generator + promise
//   - generator的done为false时,递归
//   - generator的done为true时,递归终止,resolve结果
// - generator的value和done状态是迭代器协议的返回值

/**
 * async的实现
 * @author waldon
 * @param {*} generatorFn - 生成器函数
 */
function asyncWrapper(generatorFn) {
  const g = generatorFn()
  return new Promise((resolve, reject) => {
    function autoNext(g, nextVal) {
      const { value, done } = g.next(nextVal)
      if (!done) {
        value.then((res) => {
          autoNext(g, res)
        })
      } else {
        resolve(value)
      }
    }
    autoNext(g)
  })
}

// 测试
const getData = () =>
  new Promise((resolve) => setTimeout(() => resolve('data'), 1000))

function* testG() {
  const data = yield getData()
  console.log('data: ', data)
  const data2 = yield getData()
  console.log('data2: ', data2)
  return 'success'
}

asyncWrapper(testG).then((res) => {
  console.log(res)
})

// 期望顺序输出 data data2 success

实现一个异步的 sum/add

这里有一道不错的面试题,水平较高,涉及 promise、串行、并行、并发控制,层次递进

查看详细: 实现一个异步的 sum/add

并发控制 async-pool

解析源码 tiny-async-pool

  • asyncPool(concurrency, iterable, iteratorFn)

在有限的并发池中运行多个承诺返回和异步函数。一旦其中一个承诺被拒绝,它就会立即拒绝。它会尽快调用迭代器函数(在并发限制下)。它返回一个异步迭代器,该迭代器在承诺完成后立即生成(在并发限制下)。

asyncPool 有如下三个版本的实现

js
// ES9
async function* asyncPool(concurrency, iterable, iteratorFn) {
  const executing = new Set()
  async function consume() {
    const [promise, value] = await Promise.race(executing)
    executing.delete(promise)
    return value
  }
  for (const item of iterable) {
    // Wrap iteratorFn() in an async fn to ensure we get a promise.
    // Then expose such promise, so it's possible to later reference and
    // remove it from the executing pool.
    const promise = (async () => await iteratorFn(item, iterable))().then(
      (value) => [promise, value]
    )
    executing.add(promise)
    if (executing.size >= concurrency) {
      yield await consume()
    }
  }
  while (executing.size) {
    yield await consume()
  }
}

// 用法 1
import asyncPool from 'tiny-async-pool'

const timeout = (ms) =>
  new Promise((resolve) => setTimeout(() => resolve(ms), ms))

// ES9 for await...of
for await (const value of asyncPool(2, [1000, 5000, 3000, 2000], timeout)) {
  console.log(value)
}

// 用法 2
async function asyncPoolAll(...args) {
  const results = [];
  for await (const result of asyncPool(...args)) {
    results.push(result);
  }
  return results;
}

// ES7 API style available on our previous 1.x version
const results = await asyncPoolAll(concurrency, iterable, iteratorFn);

// ES6 API style available on our previous 1.x version
return asyncPoolAll(2, [1000, 5000, 3000, 2000], timeout).then(results => {...});
js
// ES7
async function asyncPool(poolLimit, iterable, iteratorFn) {
  const ret = []
  const executing = new Set()
  for (const item of iterable) {
    const p = Promise.resolve().then(() => iteratorFn(item, iterable))
    ret.push(p)
    executing.add(p)
    const clean = () => executing.delete(p)
    p.then(clean).catch(clean)
    if (executing.size >= poolLimit) {
      await Promise.race(executing)
    }
  }
  return Promise.all(ret)
}
js
// ES6
function asyncPool(poolLimit, iterable, iteratorFn) {
  let i = 0
  const ret = []
  const executing = new Set()
  const enqueue = function () {
    if (i === iterable.length) {
      return Promise.resolve()
    }
    const item = iterable[i++]
    const p = Promise.resolve().then(() => iteratorFn(item, iterable))
    ret.push(p)
    executing.add(p)
    const clean = () => executing.delete(p)
    p.then(clean).catch(clean)
    let r = Promise.resolve()
    if (executing.size >= poolLimit) {
      r = Promise.race(executing)
    }
    return r.then(() => enqueue())
  }
  return enqueue().then(() => Promise.all(ret))
}