本文写于 2020 年 5 月 13 日

    最近代码写着写着，我突然意识到一个问题——我们既然已经有了 Promise 和 then，为啥还需要 async 和 await？

    这不是脱裤子放屁吗？

    比如说我们需要一段请求服务器的代码：

    1. new Promise((resolve, reject) => {
    2.   setTimeout(() => {
    3.     const res = '明月几时有'
    4.     if (1 > 2) {
    5.       resolve(res)
    6.     } else {
    7.       reject('我不知道，把酒问青天吧')
    8.     }
    9.   }, 1500)
    10. }).then(
    11.   (res) => {
    12.     console.log(`成功啦！结果是${res}`)
    13.   },
    14.   (err) => {
    15.     console.log(`失败了。。。错误是${err}`)
    16.   }
    17. )

    如果看不懂，可以看我之前写的一篇，什么叫做 Promise？

    这段代码，简洁漂亮，但是如果用上了 async 和 await，就需要写成下面这样：

    1. function ask() {
    2.   return new Promise((resolve, reject) => {
    3.     setTimeout(() => {
    4.       const res = '明月几时有'
    5.       if (1 > 2) {
    6.         resolve(res)
    7.       } else {
    8.         reject('我不知道，把酒问青天吧')
    9.       }
    10.     }, 1500)
    11.   })
    12. }
    14. async function test() {
    15.   try {
    16.     const res = await ask()
    17.   } catch (err) {
    18.     console.log(err)
    19.   }
    20. }
    22. test()

    竟然还需要一个 try catch 来捕捉错误！越写越像 Java 呀。

    MDN 给我们了一些解释：

    如果你在代码中使用了异步函数，就会发现它的语法和结构会更像是标准的同步函数。

    说白了，这种写法的一部分原因，就是为了“讨好” Java 和其他的一些程序员。

    另一方面呢，也是增强可读性，虽然说 async await 的写法比较丑，但是毫无疑问，可读性远远高于 Promise then。

    最为重要的呢，是 Promise 可以无限嵌套，而 async await 只能处理一个 Promise，无法继续嵌套。

    所以一旦需要使用多次连续回调，async await 就乏力了。

    其实也可以，通过 await 一个Promise.all()来实现。

    （完）