手写 async/await 的实现 ​

/**
 * 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))

// 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 => {...});