1.2 Promise-止水(async+await+手写)

269 阅读3分钟

1.为什么需要引入 async/awawit

异步操作是Js的麻烦事,通过回调进行操作对我们来说很麻烦,从Promise对象到Generator函数,异步编程的最高境界,就是根本 不用关心它是不是异步。async 函数就是隧道尽头的亮光,很多人认为它是异步操作的终极解决方案。

2.生成器(generator)

为什么要说这个生成器,一句话,async 函数就是 Generator 函数的语法糖。只是生成器它不能自动迭代,只能手动触发

function* gen() {
  yield 1;
  yield 2;
  yield 3;
}
g.next() // { value: 1, done: false }
g.next() // { value: 2, done: false }
g.next() // { value: 3, done: false }
  • g.next() 返回的是一个对象 { value: 1, done: false }
  • value 每调一次就会执行下一个 yield,value 就是 yield 的一个值,比如第一次就是 1,第二次就是 2
  • done done 的值为 true 则说明下面已经没有可迭代项了
  • yield 你可以认为是一个 return,会阻断下面代码的执行,并且会将后面的数值返回回去 我们再看看async的用法
async function gen() {
  await 1;
  await 2;
  await 3;
}
g()

会不会发现长得有点差不多,我们可以试想一下,如果生成器可以自动执行 .next 的方法的话,我们这不是约等于实现了 async/await 了?

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

    // 返回一个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)
        } 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")
    })
  }
}

本文有所拷贝,忘记出处。。。那啥如果大家知道链接的话,希望私信我补上感谢!