function* gen() {
  yield 1
  yield 2
  yield 3
}
const g = gen()
console.log(g.next()) // { value: 1, done: false }
console.log(g.next()) // { value: 2, done: false }
console.log(g.next()) // { value: 3, done: false }
// 可以看到最后一个是undefined，这取决于你generator函数有无返回值
console.log(g.next()) // { value: undefined, done: true }

// 模拟异步操作
function fn(nums) {
    return new Promise(resolve => {
        setTimeout(() => {
            resolve(nums * 2)
        }, 1000)
    })
}
// 生成器函数
function* gen() {
    console.time('test')
    const num1 = yield fn(1)
    const num2 = yield fn(num1)
    const num3 = yield fn(num2)
    console.timeEnd('test')
    return num3
}
function generatorToAsync(generatorFn) {
    return function () {
        // generatorFn有可能传参
        const gen = generatorFn.apply(this.arguments)
        // 模拟async函数返回一个Promise对象
        return new Promise((resolve, reject) => {
            // 定义一个go函数，用来自动执行 gen.next() 方法
            function go(key, arg) {
                let res
                try {
                    // 相当于res = gen.next('参数')
                    res = gen[key](arg) // 这里有可能会执行返回reject状态的Promise
                } catch (error) {
                    return reject(error) // 报错的话会走catch，直接reject
                }

                // 解构获得value和done
                const { value, done } = res
                if (done) {
                    // 如果done为true，说明走完了，进行resolve(value)
                    return resolve(value)
                } else {
                    // 如果done为false，说明没走完，还得继续走

                    // value有可能是：常量、Promise，Promise有可能是成功或者失败
                    return Promise.resolve(value).then(val => go('next', val), err => go('throw', err))
                }

            }
            go('next')// 第一次执行
        })
    }
}
// 测试代码
const genToAsync = generatorToAsync(gen)// 生成async函数构造器函数
const asyncRes = genToAsync()// 生成async函数
console.log(asyncRes);// async函数返回的是Promise
asyncRes.then(res=>{
    // test: 3032.6279296875 ms
    console.log(res);// 3秒后输出8
})