Async/Await 边学边练

最新推荐文章于 2025-04-26 18:23:02 发布
最新推荐文章于 2025-04-26 18:23:02 发布
阅读量139 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： python
原文链接：https://my.oschina.net/u/2510955/blog/1558846
本文介绍了 Async/Await 的发展历程及在 Node.js 中的应用实践，包括顺序与并行执行、循环处理等场景，并展示了如何优雅地处理异常。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

Async/Await是ES2017中加入的新特性，解救众生于Promise

这篇文章主要根据Async/Await的一个介绍视频，截图供大家入门学习

1 发展历史

 

callback最受诟病的就是嵌套的括号，不美观，错误处理也复杂

 

Promise就好很多，结构清晰，统一错误处理

 

主角Async/Await登场了，传统的函数调用方式，线性编程方式

 

示例

注意：下面的示例需要在node>=7.6的环境下，支持async/wait

  • 1-sequential

 1-1-naive

 记录两个方法运行的时间，总共运行的时间

 processes.js

const util = require('util')
const wait = util.promisify(setTimeout)

module.exports = {
  async process01 () {
    console.log('Process 01 started')
    console.time('Process 01 ended')
    await wait(5000)
    console.timeEnd('Process 01 ended')
    console.log()
    return 'process01-value'
  },

  async process02 () {
    console.log('Process 02 started')
    console.time('Process 02 ended')
    await wait(3000)
    console.timeEnd('Process 02 ended')
    console.log()
    return 'process02-value'
  }
}

第一行的util是nodejs自带的工具类，本机需要安装node

第二行util.promisify() 用于将那些接受回调函数的函数，转变为 Promise

 

main.js

const {process01, process02} = require('./processes')

async function main () {
  try {
    console.time('Total Running Time')
    const value01 = await process01()
    const value02 = await process02()

    console.log('Process 01 Returned: ', value01)
    console.log('Process 02 Returned: ', value02)

    console.log()

    console.timeEnd('Total Running Time')
  } catch (error) {
    console.error('error', error)
  }
}

main()

 

结果

155618_slOp_2510955.png

  
1-2-issue

异常处理，如果被调用函数没有处理异常，则会中断执行调用函数

processes.js

const util = require('util')
const wait = util.promisify(setTimeout)

module.exports = {
  async process01 () {
    console.log('Process 01 started')
    throw new Error('Process 01 Failed')
    console.time('Process 01 ended')
    await wait(5000)
    console.timeEnd('Process 01 ended')
    console.log()
    return 'process01-value'
  },

  async process02 () {
    console.log('Process 02 started')
    console.time('Process 02 ended')
    await wait(3000)
    console.timeEnd('Process 02 ended')
    console.log()
    return 'process02-value'
  }
}

 

main.js

const {process01, process02} = require('./processes')

async function main () {
  try {
    console.time('Total Running Time')
    const value01 = await process01()
    const value02 = await process02()

    console.log('Process 01 Returned: ', value01)
    console.log('Process 02 Returned: ', value02)

    console.log()

    console.timeEnd('Total Running Time')
  } catch (error) {
    console.error('error', error)
  }
}

main()

 

结果

160449_X5Kz_2510955.png

 

1-3-solution

针对1-2-issue的错误处理，在process01中增加了异常处理，不会中断调用函数的执行

processes.js

const util = require('util')
const wait = util.promisify(setTimeout)

module.exports = {
  async process01 () {
    try {
      console.log('Process 01 started')
      throw new Error('Process 01 Failed')
      console.time('Process 01 ended')
      await wait(5000)
      console.timeEnd('Process 01 ended')
      console.log()
      return 'process01-value'
    } catch (error) {
      console.error(error)
    }
  },

  async process02 () {
    try {
      console.log('Process 02 started')
      console.time('Process 02 ended')
      await wait(3000)
      console.timeEnd('Process 02 ended')
      console.log()
      return 'process02-value'
    } catch (error) {
      console.error(error)
    }
  }
}

               

main.js

const {process01, process02} = require('./processes')

async function main () {
  try {
    console.time('Total Running Time')
    const value01 = await process01()
    const value02 = await process02()

    console.log('Process 01 Returned: ', value01)
    console.log('Process 02 Returned: ', value02)

    console.log()

    console.timeEnd('Total Running Time')
  } catch (error) {
    console.error('error', error)
  }
}

main()

 

结果

161021_Wg0X_2510955.png

 

  • 02-parallel

2-1-naive

并行执行异步函数

processes.js

const util = require('util')
const wait = util.promisify(setTimeout)

module.exports = {
  async process01 () {
    console.log('Process 01 started')
    console.time('Process 01 ended')
    await wait(5000)
    console.timeEnd('Process 01 ended')
    console.log()
    return 'process01-value'
  },

  async process02 () {
    console.log('Process 02 started')
    console.time('Process 02 ended')
    await wait(3000)
    console.timeEnd('Process 02 ended')
    console.log()
    return 'process02-value'
  }
}

 

main.js

const {process01, process02} = require('./processes')

async function main () {
  try {
    console.time('Total Running Time')
    const data = await Promise.all([process01(), process02()]) // 并行执行

    console.log()

    console.log('Process 01 Returned: ', data[0])
    console.log('Process 02 Returned: ', data[1])

    console.log()

    console.timeEnd('Total Running Time')
  } catch (error) {
    console.error('error', error)
  }
}

main()

 

结果

161722_GQhZ_2510955.png

 

2-2-issue

并行执行2个函数，其中一个异步函数抛异常，不影响另一个函数的执行，但影响返回之后的操作

processes.js

 

const util = require('util')
const wait = util.promisify(setTimeout)

module.exports = {
  async process01 () {
    console.log('Process 01 started')
    throw new Error('Process 01 Failed')
    console.time('Process 01 ended')
    await wait(5000)
    console.timeEnd('Process 01 ended')
    console.log()
    return 'process01-value'
  },

  async process02 () {
    console.log('Process 02 started')
    console.time('Process 02 ended')
    await wait(3000)
    console.timeEnd('Process 02 ended')
    console.log()
    return 'process02-value'
  }
}

 

main.js

const {process01, process02} = require('./processes')

async function main () {
  try {
    console.time('Total Running Time')
    const data = await Promise.all([process01(), process02()]) // 并行执行

    console.log()

    console.log('Process 01 Returned: ', data[0])
    console.log('Process 02 Returned: ', data[1])

    console.log()

    console.timeEnd('Total Running Time')
  } catch (error) {
    console.error('error', error)
  }
}

main()

 

结果

162723_BPhr_2510955.png

 

2-3-solution

被调用的异步函数添加异常处理，同样可以返回执行结果，不影响调用函数的继续执行

processes.js

const util = require('util')
const wait = util.promisify(setTimeout)

module.exports = {
  async process01 () {
    try {
      console.log('Process 01 started')
      throw new Error('Process 01 Failed')
      console.time('Process 01 ended')
      await wait(5000)
      console.timeEnd('Process 01 ended')
      console.log()
      return 'process01-value'
    } catch (error) {
      console.error(error)
    }
  },

  async process02 () {
    try {
      console.log('Process 02 started')
      console.time('Process 02 ended')
      await wait(3000)
      console.timeEnd('Process 02 ended')
      console.log()
      return 'process02-value'
    } catch (error) {
      console.error(error)
    }
  }
}

 

main.js

const {process01, process02} = require('./processes')

async function main () {
  try {
    console.time('Total Running Time')
    const data = await Promise.all([process01(), process02()]) // 并行执行

    console.log()

    console.log('Process 01 Returned: ', data[0])
    console.log('Process 02 Returned: ', data[1])

    console.log()

    console.timeEnd('Total Running Time')
  } catch (error) {
    console.error('error', error)
  }
}

main()

 

结果

163354_AvDG_2510955.png

 

 

  • 03-loops

3-1-for-loop

某个方法的benchmark, 循环执行10次，计算总耗时和平均耗时

processes.js

const util = require('util')
const wait = util.promisify(setTimeout)

function getRandBetween (a, b) {
  return Math.floor(Math.random() * b) + a
}

module.exports = {
  async secretAlgorithm () {
    console.time('secretAlgorithm')
    await wait(getRandBetween(1, 7) * 100)
    console.timeEnd('secretAlgorithm')
  }
}

 

main.js

const now = require('performance-now')
const {secretAlgorithm} = require('./processes')

const NUMBER_OF_RUNS = 10

async function main () {
  try {
    let totalTime = 0
    for (let i = 0; i < NUMBER_OF_RUNS; i++) {
      const start = now()
      await secretAlgorithm()
      const end = now()
      totalTime += (end - start)
    }
    console.log()

    console.log('totalTime: ', totalTime)
    console.log('Number of retries: ', NUMBER_OF_RUNS)
    console.log('Average Running Time: ', (totalTime / NUMBER_OF_RUNS).toFixed(3))

  } catch (error) {
    console.error('error', error)
  }
}

main()

 

结果

163937_10W1_2510955.png

 

3-2-forEach

植5棵树，打印每棵树开关的时间, forEach中不能使用await, 可以使用 for...of 替代

PowerPlant.js

const util = require('util')
const wait = util.promisify(setTimeout)

function getRandBetween (a, b) {
  return Math.floor(Math.random() * b) + a
}
class PowerPlant {
  constructor (id) {
    this.id = id
  }

  async turnOn () {
    console.log(`Turning On Power Plant ${this.id}`)
    console.time(`Power Plant ${this.id} turned on`)
    await wait(getRandBetween(1, 5) * 200)
    console.timeEnd(`Power Plant ${this.id} turned on`)
    console.log()
  }

  async turnOff () {
    console.log(`Turning Off Power Plant ${this.id}`)
    console.time(`Power Plant ${this.id} turned off`)
    await wait(getRandBetween(1, 3) * 200)
    console.timeEnd(`Power Plant ${this.id} turned off`)
    console.log()
  }
}

module.exports = PowerPlant

 

main.js

const PowerPlant = require('./PowerPlant')
let powerPlants = []

async function main () {
  try {
    powerPlants.push(new PowerPlant('01'))
    powerPlants.push(new PowerPlant('02'))
    powerPlants.push(new PowerPlant('03'))
    powerPlants.push(new PowerPlant('04'))
    powerPlants.push(new PowerPlant('05'))

    /* turn on all of them */
    powerPlants.forEach(powerPlant => {
      await powerPlant.turnOn()
    })

    /* turn off all of them */
    powerPlants.forEach(powerPlant => {
      await powerPlant.turnOff()
    })
  } catch (error) {
    console.error('error', error)
  }
}

main()

 

结果

164417_XX0c_2510955.png

 

3-3-for-of

processes.js

const util = require('util')
const wait = util.promisify(setTimeout)

function getRandBetween (a, b) {
  return Math.floor(Math.random() * b) + a
}
class PowerPlant {
  constructor (id) {
    this.id = id
  }

  async turnOn () {
    console.log(`Turning On Power Plant ${this.id}`)
    console.time(`Power Plant ${this.id} turned on`)
    await wait(getRandBetween(1, 5) * 200)
    console.timeEnd(`Power Plant ${this.id} turned on`)
    console.log()
  }

  async turnOff () {
    console.log(`Turning Off Power Plant ${this.id}`)
    console.time(`Power Plant ${this.id} turned off`)
    await wait(getRandBetween(1, 3) * 200)
    console.timeEnd(`Power Plant ${this.id} turned off`)
    console.log()
  }
}

module.exports = PowerPlant

 

main.js

const PowerPlant = require('./PowerPlant')
let powerPlants = []

async function main () {
  try {
    powerPlants.push(new PowerPlant('01'))
    powerPlants.push(new PowerPlant('02'))
    powerPlants.push(new PowerPlant('03'))
    powerPlants.push(new PowerPlant('04'))
    powerPlants.push(new PowerPlant('05'))

    /* turn on all of them */
    for(let powerPlant of powerPlants) {
      await powerPlant.turnOn()
    }

    /* turn off all of them */
    for(let powerPlant of powerPlants) {
      await powerPlant.turnOff()
    }
  } catch (error) {
    console.error('error', error)
  }
}

main()

 

结果

164851_q6di_2510955.png

 

3-4-while

某个方法的benchmark, 计算循环执行10次的耗时和平均耗时

processes.js
const util = require('util')
const wait = util.promisify(setTimeout)

function getRandBetween (a, b) {
  return Math.floor(Math.random() * b) + a
}

module.exports = {
  async secretAlgorithm () {
    console.time('secretAlgorithm')
    await wait(getRandBetween(1, 7) * 100)
    console.timeEnd('secretAlgorithm')
  }
}

 

main.js

const now = require('performance-now')
const {secretAlgorithm} = require('./processes')

const NUMBER_OF_RUNS = 10

async function main () {
  try {
    let totalTime = 0
    let retries = 0
    while (retries < NUMBER_OF_RUNS) {
      const start = now()
      await secretAlgorithm()
      const end = now()
      totalTime += (end - start)
      retries++
    }
    console.log()

    console.log('totalTime: ', totalTime)
    console.log('Number of retries: ', NUMBER_OF_RUNS)
    console.log('Average Running Time: ', (totalTime / NUMBER_OF_RUNS).toFixed(3))

  } catch (error) {
    console.error('error', error)
  }
}

main()

 

结果

165225_7aqk_2510955.png

 

https://www.youtube.com/watch?v=f57IHEeDNcA

转载于:https://my.oschina.net/u/2510955/blog/1558846

今天的码农女孩做了关于异步async的笔记和结合await的练习
m0_64444606的博客
04-21 1313
异步：不连续执行的 1.流程控制：分以下几个部分： 回调函数Callback; 异步 Javascript; 事件监听; 发布/订阅; Promise/a+; 生成器Generators/yield; Async/await 2.协程：意思是多个线程互相协作，完成异步任务，协程有点像函数又有点像线程，运行流程大致如下： 第一步，协程A开始执行 第二步，协程A执行到一半，...
Promise与async/await
yuren_xia的博客
01-19 1403
Promise和是JavaScript中处理异步操作的两种重要方式。
async await练习随笔
mo_jiu的博客
08-30 344
(function(){ /* async function timeout(){ return "hello async"; } timeout().then(result => { console.log(result); }) //conso...
async await 小练习
y18774585870的博客
04-23 262
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>asy
异步async await 相关知识点总结以及代码练习
tangdou369098655的博客
09-19 200
<script> const setTimeoutToPromise = duration => new Promise(resolve => { setTimeout(resolve, duration) }) export default { data() { return { mysrc: true ...
Swift 并发编程：Async/Await 特性的使用与场景分析
最新发布
数字魔方操控师的博客
04-26 893
Swift 的 Async/Await 特性为开发者提供了一种强大而直观的异步编程方式，极大地改善了异步代码的可读性和可维护性。通过在网络请求、文件读写、数据库操作、多任务并发执行以及与 UI 交互等多种场景中的应用，可以看到 Async/Await 能够有效地简化异步逻辑，提高开发效率。然而，在使用 Async/Await 特性时，开发者也需要注意线程安全、任务取消和性能等方面的问题。
详解小程序原生使用ES7 async/await语法
10-18
小程序原生使用ES7 async/await语法是现代JavaScript异步编程的简洁语法糖，它能够使异步代码的书写更加直观和易于理解。async/await是基于Promise的一种语法，可以让异步操作以同步的方式书写，提高代码的可读性...
C#关键字async/await用法
12-23
经过一番的探索，终于搞清楚关键字async/await 在.net4.5之后可用的巧妙之处，在这里记录一下也与大家分享一下个人的心得体会 async：异步执行 await：异步执行中的等待其执行完(最大的优点是它是后台等待，因此不...
深入理解ES7的async/await的用法
08-29
深入理解ES7的async/await用法 ES7的async/await是解决JavaScript异步编程的重要概念，它能够使得异步代码更易读、更易维护。本文将深入探讨async/await的用法，并与Promise和co模块进行比较。 1. async/await是...
FPGA／CPLD边练边学—快速入门Verilog／VHDL
07-08
特权的《FPGA／CPLD边练边学—快速入门Verilog／VHDL》，缺“第4章 Verilog与VHDL语法基础”。
《FPGA／CPLD边练边学—快速入门Verilog／VHDL》源程序
07-08
特权的《FPGA／CPLD边练边学—快速入门Verilog／VHDL》配套例程。
前端基础知识练习题---Promise + async/await 练习题
qq_43477721的博客
12-12 1523
前端基础知识练习题
Async 详解
热门推荐
服务器端攻城师
03-20 2万+
一：流程控制 为了适应异步编程，减少回调的嵌套，我尝试了很多库。最终觉得还是async最靠谱。 地址：https://github.com/caolan/async Async的内容分为三部分： 流程控制：简化十种常见流程的处理集合处理：如何使用异步操作处理集合中的数据工具类：几个常用的工具类 本文介绍其中最简单最常用的流程控制部分。 由于nodejs是异步编程模型，有一些在同
nodeJs安装及常见问题
u011679955的博客
06-27 836
1、nodeJs 环境安装？ 进入官网：http://www.nodejs.org/ 根据操作系统，下载相应的安装包，直接安装即可。 2、npm 安装？ a) 如果系统没有安装过Git，可以直接到https://github.com/isaacs/npm下载npm所需要的文件。 b) 如果有Git 可以使用git下载。 git clone --recursive git://gith
vue构建项目常见问题
V_AYA_V的博客
10-17 814
1.vue安装node-moudle报node-sass安装失败 解决方法： 1.npm uninstall node-sass 2.npm install node-sass --registry=https://registry.npm.taobao.org
这个问题怎么解决
2301_80152317的博客
06-25 414
npm errornpm error。
Async详解之二：工具类
rayi_hong的专栏
03-23 927
转载：http://freewind.me/blog/20120517/931.html 相比“之一”，这一篇要简单很多，算是中场休息，为下半场的“集合处理”做准备。 Async中提供了几个工具类，给我们提供一些小便利： memoizeunmemoizelogdirnoConflict 1. memoize(fn, [hasher]) 有一些方法比较耗时，且对于相同的输入总是有相同的
教你用 Node 创建 CLI 工具
qq_43327962的博客
12-12 769
准备工作 创建工程 mkdir my-cli cd my-cli npm init -y npm i commander download-git-repo ora handlebars figlet clear chalk open watch -S 创建 bin 目录 package.json 添加 bin 字段，将自定义的命令软连到全局环境，同时执行 npm link 创建链接。 "bin": { "wbiao": "./bin//index.js" } 在根目录下创建
Async/Await vs Promise：6个选择Async/Await的理由
"本文讨论了Async/Await作为替代Promise的6个主要原因，强调了其在编写异步代码时的优势，并提供了示例代码进行说明。" Async/Await与Promise的对比 1. 更清晰的代码结构：Async/Await的一个显著优势是它使异步...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值