乐趣区

关于前端:asyncawait其实是generator和promise的语法糖

jiezi

async 关键字用于申明异步函数，await 用于在 async 函数中将异步代码变为同步，阻塞代码的执行

对于 promise 和 generator 不相熟的敌人能够移步看看这些文章

Promise 的了解与应用 (一)
Promise 的了解和应用(二)
手写 promise 之分步解析
javascript 事件循环机制及面试题详解

async、await 的推导

咱们用案例推出 async await 关键字的作用。
异步函数 getRequestData，作用是期待 2s 将输出的函数返回。

function getRequestData(data) {return new Promise((resolve, reject) => {setTimeout(() => {resolve(data);
    }, 2000);
  });
}

间断调用函数 3 次，传入 ”aaa”，并顺次拼接 “bbb”, “ccc”，最初的后果为，期待 6s 输入 “aaabbbccc”。

回调天堂式实现
getRequestData("aaa").then((res) => {getRequestData(res + "bbb").then((res) => {getRequestData(res + "ccc").then((res) => {console.log("result", res);
    });
  });
});

回调天堂式代码可读性和可维护性都很差，为解决这一问题，咱们尝试链式调用。

链式调用
getRequestData("aaa")
  .then((res) => {return getRequestData(res + "bbb");
  })
  .then((res) => {return getRequestData(res + "ccc");
  })
  .then((res) => {console.log("res", res);
  });

通过链式调用使得代码可读性稍强了一些，但这样的代码还是不太好了解，再来对其进行优化

generator
function* showData() {const res1 = yield getRequestData("aaa");
  const res2 = yield getRequestData(res1 + "bbb");
  const res3 = yield getRequestData(res2 + "ccc");
  console.log("res", res3);
}

const generator = showData();
generator.next().value.then(res=>{generator.next(res).value.then(res=>{generator.next(res).value.then(res=>{console.log(res)
    })
  })
})

通过 yield 来对函数传参加取值，generator 函数中进行申请的代码就变得简略起来，但 next 调用仿佛更加简单了，依然有函数嵌套的状况，不过调用 next 办法是有迹可循的，能够用递归来实现。

const generator = showData();
function execGenerator(generator){function exec(res){const gen = generator.next(res)
    if(gen.done){return gen.value}
    return gen.value.then(re=>{exec(re)
    })
  }
  exec()}
execGenerator(generator)

封装 next 办法调用之后，异步申请就变得像同步代码一样，能够期待上一个函数执行胜利再调用下一个函数，且使得代码可读性更强。

aysnc、await

最终 async、await 版代码如下所示，其实就是 generator 和 promise 的语法糖，省去了 next 办法递归的过程。

async function showData(){const res1 = await getRequestData("aaa");
  const res2 = await getRequestData(res1 + "bbb");
  const res3 = await getRequestData(res2 + "ccc");
  console.log("res", res3);
}
showData()

async 函数与一般函数的区别

返回值

async 函数也能够有返回值，它的返回值与 promise 一样分为三种类型

  • 返回值为根本数据类型，会被 Promise.resolve 包裹，执行胜利的回调
  • 返回值为 promise，执行的后果与该 promise 统一
  • 返回值为实现了 thenable 的对象，执行后果为 then 函数中的后果
async function foo() {
  // return 'hello'
  
  // return new Promise((resolve, reject)=>{//   reject('fail')
  // })
  
  return {then: (resolve, reject) => {reject("fail");
    },
  };
}

const promise = foo();
promise
  .then((res) => {console.log("res:", res);
  })
  .catch((err) => {console.log("err:", err);
  });

thenable 中返回 reject，所以异步函数的后果也为 reject，执行 catch 函数的逻辑

抛出异样

一般函数中抛出异样，会间接中断程序的执行，前面的代码都不会执行

function bar(){throw new Error('error')
}
bar()
console.log('下面代码抛出异样了')

而异步函数中抛出异样，只须要定义 catch 办法，是不会中断程序执行的

async function foo() {throw new Error('error')
}
const promise = foo();
promise
  .then((res) => {console.log("res:", res);
  })
  .catch((err) => {console.log("进入了 catch 办法");
  });
console.log('下面代码抛出异样了')

async 其它留神点

异步函数执行 reject

promise 可能返回 resolve 或者 reject，当执行 reject 时，async 函数执行的时候须要定义 catch 办法

function getData() {return new Promise((resolve, reject) => {setTimeout(() => {reject("fail");
    }, 1000);
  });
}
async function foo() {const promise = await getData();
  console.log(promise);
}
foo()

当没有定义 catch 办法时，是会间接报错的

await 执行后果

await 前面会跟上一个表达式，表达式会返回 promise，await 会期待 promise 执行 resolve 时，才会持续往后执行。
await 后的表达式也有三种状况，与 async 函数返回值类型统一

  • 表达式为根本数据类型，会被 Promise.resolve 包裹，会执行胜利
  • 表达式为 promise，执行的后果与该 promise 统一
  • 表达式为实现了 thenable 的对象，执行后果为 then 函数中的后果
async function foo() {await Promise.reject("promise 执行了 reject 办法");
  console.log("await 上面一行代码还会执行吗");
}
foo().catch((err) => {console.log("err", err);
});
console.log("全局的代码呢");

当 await 后的表达式执行失败时，前面的代码就不会执行了

async 函数的执行程序

await 上面的代码须要等到 await 后的表达式执行实现才执行

async function bar() {console.log("2");
  return new Promise((resolve) => {resolve();
  });
}
async function foo() {console.log("1");
  await bar();
  console.log("3");
}
foo();
console.log("4");

await 后的表达式其实会执行 promise 的办法，所以 await 上面的代码其实会放到微工作中

面试题

async function async1 () {console.log('async1 start')
  await async2();
  console.log('async1 end')
}

async function async2 () {console.log('async2')
}

console.log('script start')

setTimeout(function () {console.log('setTimeout')
}, 0)
 
async1();
 
new Promise (function (resolve) {console.log('promise1')
  resolve();}).then (function () {console.log('promise2')
})
console.log('script end')
  • 函数 async1、async2 被定义，然而没有调用，首先输入 “script start”
  • setTimeout 中的的内容会被放到宏工作队列中，最初执行
  • 调用函数 async1，输入 “async1 start”，执行函数 async2，输入 “async2″，函数 async2 下方的输入 ”async1 end” 将会被放到微工作队列中
  • 执行 promise 的 executor 局部，输入 “promise1″，then 办法里的输入 ”promise2″ 将被放到微工作队列中
  • 输入 “script end”
  • 执行微工作队列中的代码，顺次输入 “async1 end”、”promise2”
  • 执行宏工作队列中的代码，输入 “setTimeout”

图示如下

执行后果如下

以上就是 async、await 的推导过程及用法，对于 js 高级，还有很多须要开发者把握的中央，能够看看我写的其余博文，继续更新中~

退出移动版