Async/Await替代Promise的6个理由
分类:前端技术

Async/Await替代Promise的6个理由

2017/04/02 · JavaScript · async, await

原来的作品出处: Mostafa Gaafar   译文出处:Fundebug   

译者按: Node.js的异步编制程序形式可行狠抓了接受品质;但是回调鬼世界却令人恐惧,Promise让我们拜别回调函数,写出更文雅的异步代码;在进行进程中,却开采Promise并不完备;本事升高是向前的,那时,大家有了Async/Await。

Node.js 7.6已经帮助async/await了,尽管您还从未试过,那篇博客将告诉你怎么要用它。

Async/Await简介

  • async/await是写异步代码的新措施,从前的法门有回调函数和Promise。
  • async/await是依照Promise达成的,它不可能用于平日的回调函数。
  • async/await与Promise相通,是非梗塞的。
  • async/await使得异步代码看起来像一块代码,那正是它的魔力随处。

Async/Await简介

对于尚未据书上说过async/await的对象,上边是简单介绍:

  • async/await是写异步代码的新点子,此前的办法有回调函数PromiseAsync/Await替代Promise的6个理由。。
  • async/await是基于Promise达成的,它无法用来普通的回调函数。
  • async/await与Promise同样,是非堵塞的。
  • async/await使得异步代码看起来像生龙活虎道代码,那多亏它的吸重力四处。

Async/Await语法

Promise写法:

const makeRequest = () =>
  getJSON()
    .then(data => {
      console.log(data)
      return "done"
    })
makeRequest()

Async/Await写法:

const makeRequest = async () => {
  console.log(await getJSON())
  return "done"
}
makeRequest()

亲自去做中,getJSON函数重返八个promise,那个promise成功resolve时会重临八个promise对象。大家只是调用那么些函数,打字与印刷重临的JSON对象,然后回到“done”。

它们有点细微不一样:

  • 函数前边多了一个async关键字。await关键字只好用在async定义的函数内。async函数会隐式的回来二个promise,该promise的resolve值正是函数return的值。(示例中resolve值正是字符串"done"卡塔尔
  • 第1点暗中提示大家无法在最外层代码中运用await,因为不在async函数内。
//不能在最外层代码中使用await
await makeRequest()

//这是会出事的
makeRequest().then((result) => {
  //代码
})

await getJSON(卡塔尔(英语:State of Qatar)表示console.log会等到getJSON的promise成功reosolve之后再实践。

Async/Await语法

示范中,getJSON函数再次回到七个promise,这么些promise成功resolve时会再次回到多少个json对象。大家只是调用那么些函数,打字与印刷重临的JSON对象,然后重临”done”。

利用Promise是那般的:

JavaScript

const makeRequest = () => getJSON() .then(data => { console.log(data) return "done" }) makeRequest()

1
2
3
4
5
6
7
const makeRequest = () =>
  getJSON()
    .then(data => {
      console.log(data)
      return "done"
    })
makeRequest()

行使Async/Await是这么的:

JavaScript

const makeRequest = async () => { console.log(await getJSON()) return "done" } makeRequest()

1
2
3
4
5
const makeRequest = async () => {
  console.log(await getJSON())
  return "done"
}
makeRequest()

它们有点细微不一致:

  • 函数后面多了八个aync关键字。await关键字只好用在aync定义的函数内。async函数会隐式地重临一个promise,该promise的reosolve值正是函数return的值。(示例中reosolve值就是字符串”done”卡塔尔(英语:State of Qatar)
  • 第1点暗暗提示大家不能够在最外层代码中接收await,因为不在async函数内。

JavaScript

// 不可能在最外层代码中使用await await makeRequest(卡塔尔(قطر‎ // 那是会出事情的 makeRequest(卡塔尔国.then((result卡塔尔(英语:State of Qatar) => { // 代码 }卡塔尔(英语:State of Qatar)

1
2
3
4
5
6
// 不能在最外层代码中使用await
await makeRequest()
// 这是会出事情的
makeRequest().then((result) => {
  // 代码
})

await getJSON(卡塔尔(قطر‎表示console.log会等到getJSON的promise成功reosolve之后再试行。

为什么Async/Await更好?

为什么Async/Await更好?

1. 简洁

由示例可以预知,使用Async/Await鲜明节约了过多代码。我们无需写.then,无需写无名函数管理Promise的resolve值,也不要求定义多余的data变量,还制止了嵌套代码。那些小的长处会急速累积起来,那在后来的代码示例中会尤其简明。

1. 简洁

由示例可见,使用Async/Await明显节约了超级多代码。大家没有必要写.then,无需写无名函数管理Promise的resolve值,也不必要定义多余的data变量,还防止了嵌套代码。那一个小的独特之处会飞速累加起来,那在事后的代码示例中会越发明朗。

2. 错误处理

Async/Await让try/catch能够同期管理一同和异步错误。在上面包车型地铁promise示例中,try/catch不能够管理JSON.parse的大错特错,因为它在Promise中。大家须求使用.catch,那样错误管理代码特别冗余。并且,在我们的实际生育代码会尤其目迷五色。

const makeRequest = () => {
  try {
    getJSON()
      .then(result => {
        // JSON.parse可能会出错
        const data = JSON.parse(result)
        console.log(data)
      })
      // 取消注释,处理异步代码的错误
      // .catch((err) => {
      //   console.log(err)
      // })
  } catch (err) {
    console.log(err)
  }
}

使用aync/await的话,catch能处理JSON.parse错误:

const makeRequest = async () => {
  try {
    // this parse may fail
    const data = JSON.parse(await getJSON())
    console.log(data)
  } catch (err) {
    console.log(err)
  }
}

2. 错误管理

Async/Await让try/catch能够何况管理一同和异步错误。在底下的promise示例中,try/catch无法管理JSON.parse的荒诞,因为它在Promise中。大家须求使用.catch,那样错误管理代码特别冗余。而且,在大家的实际临蓐代码会进一层复杂。

JavaScript

const makeRequest = (卡塔尔(قطر‎ => { try { getJSON(卡塔尔 .then(result => { // JSON.parse大概会出错 const data = JSON.parse(result卡塔尔(英语:State of Qatar) console.log(data卡塔尔(قطر‎}卡塔尔(英语:State of Qatar) // 撤消注释,管理异步代码的荒诞 // .catch((err卡塔尔(قطر‎ => { // console.log(err卡塔尔 // }卡塔尔(قطر‎ } catch (err卡塔尔 { console.log(err卡塔尔(英语:State of Qatar) } }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const makeRequest = () => {
  try {
    getJSON()
      .then(result => {
        // JSON.parse可能会出错
        const data = JSON.parse(result)
        console.log(data)
      })
      // 取消注释,处理异步代码的错误
      // .catch((err) => {
      //   console.log(err)
      // })
  } catch (err) {
    console.log(err)
  }
}

使用aync/await的话,catch能处理JSON.parse错误:

JavaScript

const makeRequest = async () => { try { // this parse may fail const data = JSON.parse(await getJSON()) console.log(data) } catch (err) { console.log(err) } }

1
2
3
4
5
6
7
8
9
const makeRequest = async () => {
  try {
    // this parse may fail
    const data = JSON.parse(await getJSON())
    console.log(data)
  } catch (err) {
    console.log(err)
  }
}

3. 尺度语句

上边示例中,需求获取数据,然后依据再次回到数据调整是一贯回到,还是继续得到越多的数据。

const makeRequest = () => {
  return getJSON()
    .then(data => {
      if (data.needsAnotherRequest) {
        return makeAnotherRequest(data)
          .then(moreData => {
            console.log(moreData)
            return moreData
          })
      } else {
        console.log(data)
        return data
      }
    })
}

地方的代码嵌套(6层卡塔尔(英语:State of Qatar)、括号、return语句比较轻巧令人看不懂。

使用Async/Await编写:

const makeRequest = async () => {
  const data = await getJSON()
  if (data.needsAnotherRequest) {
    const moreData = await makeAnotherRequest(data);
    console.log(moreData)
    return moreData
  } else {
    console.log(data)
    return data    
  }
}

3. 口径语句

下边示例中,需求获取数据,然后依照重返数据调控是一向回到,依旧持续得到更加多的多少。

JavaScript

const makeRequest = () => { return getJSON() .then(data => { if (data.needsAnotherRequest) { return makeAnotherRequest(data) .then(moreData => { console.log(moreData) return moreData }) } else { console.log(data) return data } }) }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const makeRequest = () => {
  return getJSON()
    .then(data => {
      if (data.needsAnotherRequest) {
        return makeAnotherRequest(data)
          .then(moreData => {
            console.log(moreData)
            return moreData
          })
      } else {
        console.log(data)
        return data
      }
    })
}

这么些代码瞧着就脑瓜疼。嵌套(6层),括号,return语句相当轻易令人感到迷茫,而它们只是需求将最终结果传递到最外层的Promise。

地点的代码应用async/await编写能够大大地抓实可读性:

JavaScript

const makeRequest = async () => { const data = await getJSON() if (data.needsAnotherRequest) { const moreData = await makeAnotherRequest(data); console.log(moreData) return moreData } else { console.log(data) return data } }

1
2
3
4
5
6
7
8
9
10
11
const makeRequest = async () => {
  const data = await getJSON()
  if (data.needsAnotherRequest) {
    const moreData = await makeAnotherRequest(data);
    console.log(moreData)
    return moreData
  } else {
    console.log(data)
    return data    
  }
}

4. 中间值

你也许蒙受过这么的场所,调用promise1,使用promise1再次回到的结果调用promise2,然后使用两个的结果调用promise3。使用promise的代码是:

const makeRequest = () => {
  return promise1()
    .then(value1 => {
      return promise2(value1)
        .then(value2 => {        
          return promise3(value1, value2)
        })
    })
}

怎么promise3不利用value1,能够超级粗略的将promise铺平。要是忍受不住嵌套,能够将value1 & value2放进Promise.all来幸免深层嵌套:

const makeRequest = () => {
  return promise1()
    .then(value1 => {
      return Promise.all([value1, promise2(value1)])
    })
    .then(([value1, value2]) => {      
      return promise3(value1, value2)
    })
}

这种艺术为了可读性就义了语义,除了制止嵌套,并未任何理由将value1和value2放在一个数组中。

行使async/await的话,代码会变得相当简单和直观:

const makeRequest = async () => {
  const value1 = await promise1()
  const value2 = await promise2(value1)
  return promise3(value1, value2)
}

4. 中间值

您十分的大概遭逢过那样的情况,调用promise1,使用promise1再次来到的结果去调用promise2,然后选拔两个的结果去调用promise3。你的代码很只怕是如此的:

JavaScript

const makeRequest = () => { return promise1() .then(value1 => { return promise2(value1) .then(value2 => { return promise3(value1, value2) }) }) }

1
2
3
4
5
6
7
8
9
const makeRequest = () => {
  return promise1()
    .then(value1 => {
      return promise2(value1)
        .then(value2 => {        
          return promise3(value1, value2)
        })
    })
}

倘若promise3无需value1,能够非常的粗略地将promise嵌套铺平。要是您忍受不住嵌套,你能够将value 1 & 2 放进Promise.all来制止深层嵌套:

JavaScript

const makeRequest = () => { return promise1() .then(value1 => { return Promise.all([value1, promise2(value1)]) }) .then(([value1, value2]) => { return promise3(value1, value2) }) }

1
2
3
4
5
6
7
8
9
const makeRequest = () => {
  return promise1()
    .then(value1 => {
      return Promise.all([value1, promise2(value1)])
    })
    .then(([value1, value2]) => {      
      return promise3(value1, value2)
    })
}

这种措施为了可读性捐躯了语义。除了幸免嵌套,并不曾经负担何理由将value1和value2放在一个数组中。

行使async/await的话,代码会变得非常简单和直观。

JavaScript

const makeRequest = async () => { const value1 = await promise1() const value2 = await promise2(value1) return promise3(value1, value2) }

1
2
3
4
5
const makeRequest = async () => {
  const value1 = await promise1()
  const value2 = await promise2(value1)
  return promise3(value1, value2)
}

5. 错误栈

const makeRequest = () => {
  return callAPromise()
    .then(() => callAPromise())
    .then(() => callAPromise())
    .then(() => callAPromise())
    .then(() => callAPromise())
    .then(() => {
      throw new Error("oops");
    })
}
makeRequest()
  .catch(err => {
    console.log(err);
    // output
    // Error: oops at callAPromise.then.then.then.then.then (index.js:8:13)
  })

上述示范中调用了多个promise,假若promise链中有些地方抛出了贰个可怜,再次回到的荒诞栈未有提交错误产生的地点消息。

async/await中的错误栈会指向错误所在的函数:

const makeRequest = async () => {
  await callAPromise()
  await callAPromise()
  await callAPromise()
  await callAPromise()
  await callAPromise()
  throw new Error("oops");
}
makeRequest()
  .catch(err => {
    console.log(err);
    // output
    // Error: oops at makeRequest (index.js:7:9)
  })

在付出进程中,大概那或多或少优势并非一点都不小。然则,借使是剖析坐蓐境遇的不当日志时,它将这多少个有效。

5. 错误栈

上面示例中调用了八个Promise,若是Promise链中有些地点抛出了八个不当:

JavaScript

const makeRequest = () => { return callAPromise() .then(() => callAPromise()) .then(() => callAPromise()) .then(() => callAPromise()) .then(() => callAPromise()) .then(() => { throw new Error("oops"); }) } makeRequest() .catch(err => { console.log(err); // output // Error: oops at callAPromise.then.then.then.then.then (index.js:8:13) })

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const makeRequest = () => {
  return callAPromise()
    .then(() => callAPromise())
    .then(() => callAPromise())
    .then(() => callAPromise())
    .then(() => callAPromise())
    .then(() => {
      throw new Error("oops");
    })
}
makeRequest()
  .catch(err => {
    console.log(err);
    // output
    // Error: oops at callAPromise.then.then.then.then.then (index.js:8:13)
  })

Promise链中回到的荒诞栈未有付诸错误爆发地点的头脑。更倒霉的是,它会误导大家;错误栈中唯风流倜傥的函数名字为callAPromise,但是它和错误没有提到。(文件名和行号依然平价的卡塔尔国。

而是,async/await中的错误栈会指向错误所在的函数:

JavaScript

const makeRequest = async () => { await callAPromise() await callAPromise() await callAPromise() await callAPromise() await callAPromise() throw new Error("oops"); } makeRequest() .catch(err => { console.log(err); // output // Error: oops at makeRequest (index.js:7:9) })

1
2
3
4
5
6
7
8
9
10
11
12
13
14
const makeRequest = async () => {
  await callAPromise()
  await callAPromise()
  await callAPromise()
  await callAPromise()
  await callAPromise()
  throw new Error("oops");
}
makeRequest()
  .catch(err => {
    console.log(err);
    // output
    // Error: oops at makeRequest (index.js:7:9)
  })

在支付情况中,那或多或少优势并一点都不大。不过,当您解析生产情况的大谬不然日志时,它将非常实用。此时,知道不当发生在makeRequest比知道不当发生在then链中要好。

6. 调试

async/await能够使代码更便于调节和测验。
promise调节和测验非常忧伤:

  • 无法在再次回到表明式的箭头函数中设置断点
const makeRequest = () => {
    return callAPromise()
      .then(() => callAPromise())
      .then(() => callAPromise())
      .then(() => callAPromise())
      .then(() => callAPromise())
}
  • 假定在.then代码块中安装断点,使用Step Over快捷键,调节和测量检验器不会调到下八个.then,因为它只会跳过异步代码。

行使async/await时,不再必要那么多箭头函数,那样就能够像调节和测量检验同步代码相符跳过await语句。

const makeRequest = async () => {
    await callAPromise()
    await callAPromise()
    await callAPromise()
    await callAPromise()
}

6. 调试

终极一点,也是那一个关键的有些在于,async/await能够使得代码调节和测量试验更简约。2个理由使得调节和测量检验Promise变得不得了难过:

  • 不能够在回来表明式的箭头函数中安装断点

图片 1

  • 万大器晚成您在.then代码块中安装断点,使用Step Over迅速键,调节和测量试验器不会跳到下贰个.then,因为它只会跳过异步代码。

选取await/async时,你不再要求那么多箭头函数,那样你就可以像调节和测验同步代码雷同跳过await语句。

图片 2

结论

Async/Await是近几年JavaScript加多的最革命性的的性状之生龙活虎。它会令你发掘Promise的语法有多不好,並且提供了三个直观的代表情势。

忧虑

对此Async/Await,可能你有部分靠边的疑忌:

  • 它使得异步代码不在鲜明: 大家已经习贯了用回调函数大概.then来分辨异步代码,大家可能需求花数个星期去习贯新的证明。不过,C#具有这些性情已经比非常多年了,熟谙它的相爱的人应该精晓一时的有一些不平价是值得的。
  • Node 7不是LTS(长时间支撑版本): 然而,Node 8前段时间就能够揭橥,将代码迁移到新版本会特别轻便。

 

1 赞 1 收藏 评论

图片 3

本文由pc28.am发布于前端技术,转载请注明出处:Async/Await替代Promise的6个理由

上一篇:HTTP/2 Server Push 安详严整(上) 下一篇:没有了
猜你喜欢
热门排行
精彩图文