Node.js 使用async模块

最新推荐文章于 2025-04-11 07:30:00 发布
最新推荐文章于 2025-04-11 07:30:00 发布
阅读量4.2k 收藏
点赞数
分类专栏： node-js 文章标签： node.js async
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/github_36704158/article/details/70174483
版权
本文介绍了如何使用Node.js的async模块进行异步编程，包括串行执行（waterfall和series函数）、并行执行以及串行和并行结合的auto函数，同时还展示了异步循环的使用示例。

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

假设要编写一些异步的代码：
- 打开路径的句柄
- 判断路径是否指向一个文件
- 如果路径指向一个文件，加载这个文件的内容
- 关闭句柄并将内容返回给调用者
函数如下所示：

var fs = require("fs");

function load_file_contents(path, callback) {
    fs.open(path, 'r', function(err, file) {
        if (err) {
            callback(err);
            return;
        } else if (!file) {
            callback({error: "无效句柄", message: "fs.open未能正确打开文件！"});
            return;
        }
        fs.fstat(file, function (err, stats) {
            if (err) {
                callback(err);
                return;
            }
            if (stats.isFile()) {
                var buf = new Buffer(10000);
                fs.read(file, buf, 0, 10000, null, function (err, br, buf) {
                    if (err) {
                        callback(err);
                        return;
                    }
                    fs.close(file, function (err) {
                        if (err) {
                            callback(err);
                            return;
                        }
                        callback(null, buf.toString('utf8', 0, br));
                    })
                })
            } else {
                callback({error: "不是文件", message: "无法加载文件夹"});
                return;
            }
        })
    });
}
//加载D盘下的info.txt文件
load_file_contents('d:/info.txt', function (err, contents) {
    if (err) {
        console.log(err);
        return;
    }
    console.log(contents);
})

不难发现，以上代码从一开始就深度嵌套。当嵌套层度超过一定程度时，代码的可读性就降低了。
要解决这个问题，可以使用async模块。

串行执行

以串行方式执行异步代码的方式有两种：waterfall函数和series函数。

waterfall函数接收一个函数数组作为参数，然后把每一个函数的结果传给下一个函数。结束时，结果函数会接收函数数组中最后一个函数的返回结果作为参数并执行。这种方式下，任何一步出错，执行都会停止。
现在用async.waterfall重写之前的代码：

var fs = require('fs');
var async = require('async');

function load_file_contents(path, callback) {
    async.waterfall([
        function (callback) {
            console.log("执行第1步");
            fs.open(path, 'r', callback);
        },

        function (file, callback) {
            console.log("执行第2步");
            fs.fstat(file, function (err, stats) {
                if (err) {
                    callback(err);
                } else {
                    callback(null, file, stats);
                }
            });
        },

        function (file, stats, callback) {
            console.log("执行第3步");
            if (stats.isFile()) {
                var buf = new Buffer(10000);
                fs.read(file, buf, 0, 10000, null, function (err, br, buf) {
                    if (err) {
                        callback(err);
                        return;
                    }
                    callback(null, file, buf.toString('utf8', 0, br));
                });
            } else {
                callback({error: "不是文件", message: "无法加载这个文件夹"});
            }
        },

        function (file, contents, callback) {
            console.log("执行第4步");
            fs.close(file, function (err) {
                if (err) {
                    callback(err);
                } else {
                    callback(null, contents);
                }
            })
        }
    ]);
}
//加载info.txt
load_file_contents('d:/info.txt', function (err, contents) {
    if (err) {
        console.log("出错！");
        return;
    }
    console.log(contents);
})

运行结果：

执行第1步
执行第2步
执行第3步
执行第4步
------------------
结果已经返回:
Hello World!
你好，世界！

async.series函数和async.waterfall函数有两个区别：
- 来自一个函数的结果不是传给下一个函数，而是收集到一个数组中，这个数组作为参数传给最后的结果函数。依次调用的每一个函数都会称为这个数组中的一个元素
- 可以给async.series传递一个对象，它会枚举每一个key并执行每个key对应的函数。这时候，结果就不是作为一个数组传入，而是对象

区别1：

var async = require('async');

function testAsyncSeries(callback) {
    async.series([
        function (callback) {
            callback(null, [1, 2, 3]);
        },

        function (callback) {
            callback(null, ['a', 'b', 'c']);
        }], 
        function (err, results) {
            callback(null, results);
        }
    );
}

testAsyncSeries(function (err, results) {
    if (err) {
        console.log(err);
        return;
    }
    console.log(results);
});

运行结果：

[ [ 1, 2, 3 ], [ 'a', 'b', 'c' ] ]

区别2：

var async = require('async');

function testAsyncSeries(callback) {
    async.series({
            numbers: function (callback) {
                callback(null, [1, 2, 3]);
            },

            strings: function (callback) {
                callback(null, ['a', 'b', 'c']);
            }
        }, 
        function (err, results) {
            callback(null, results);
        }
    );
}

testAsyncSeries(function (err, results) {
    if (err) {
        console.log(err);
        return;
    }
    console.log(results);
});

运行结果：

{ numbers: [ 1, 2, 3 ], strings: [ 'a', 'b', 'c' ] }

并行执行

在async.series的例子，函数没有理由串行执行：第二个函数并不依赖第一个函数的结果。应当以并行的方式执行它们：

var async = require('async');

function testAsyncParallel(callback) {      
    async.parallel({
            numbers : function (callback) {
                callback(null,[1, 2, 3]);
            },

            strings : function (callback) {
                callback(null,['a', 'b', 'c']);
            }
        },
        function (err, results) {
            return callback(null, results);
        }
    );
}

testAsyncParallel(function (err, results) {
    if (err) {
        console.log(err);
        return;
    }
    console.log(results);
});

运行结果：

{ numbers: [ 1, 2, 3 ], strings: [ 'a', 'b', 'c' ] }

串行和并行结合起来使用*

async模块提供了函数auto，能够将顺序执行的函数和非顺序执行的函数混合起来称为一个函数序列。使用这个函数，应传入一个对象，它的key包含了：
- 将要执行的函数，或者
- 一个依赖数组和一个将要执行的函数。这些依赖都是字符串，是提供给async.auto的对象的属性名。auto函数会等待这些依赖都执行完才会调用我们提供的函数。

举个例子：

var async = require('async');

function testAsyncAuto(callback) {
    async.auto({
            numbers: function (callback) {
                console.log("调用numbers");
                callback(null, [1, 2, 3]);
            },

            strings: function (callback) {
                console.log("调用strings");
                callback(null, ['a', 'b', 'c']);
            },

            assemble: [
                'numbers', 'strings',
                function (results, callback) {
                    callback(null,{numbers: results.numbers, strings: results.strings});
                }
            ]
    }, function (err, results) {
        callback(null, results);
    });
}

testAsyncAuto(function (err, results) {
    if (err) {
        console.log(err);
        return;
    }
    console.log(results);
});

运行结果：

{ numbers: [ 1, 2, 3 ],
  strings: [ 'a', 'b', 'c' ],
  assemble: { numbers: [ 1, 2, 3 ], strings: [ 'a', 'b', 'c' ] } }

异步循环

可以使用async.forEachSeries来遍历数组中的项：

var async = require('async');
var a = [1, 2, 3, 4, 9];

function testAsyncEachSeries(a, callback) {
    async.forEachSeries(
        a, //要遍历的数组
        function(element, callback) {
            console.log(element);//对数组元素进行的操作，我这里只是简单打印
            callback(null);//YOU MUST CALL ME FOR EACH ELEMENT!
        },
        // called at the end
        function (err) {
            callback(err);//没出错的话，err will be non-null then
        }
    );
}

testAsyncEachSeries(a, function (err) {
    if (err) {
        return;
    }
});

运行结果：

1
2
3
4
9

可以看到数组中的每一个元素都会以相同的方式被调用，但是呢它不会串行地执行函数。

Async JavaScript
09-26
Originally devised to enhance web pages in Netscape 2.0, JavaScript is now faced with being a single-threaded language in a multimedia, multitasking, multicore world. Yet JavaScript has not only persevered since 1995, it’s thrived. One after the other, potential rivals in the browser—Flash, Silverlight, and Java applets, to name a few—have come and (more or less) gone. Meanwhile, when a programmer named Ryan Dahl wanted to build a new framework for event-driven servers, he searched the far reaches of computer science for a language that was both dynamic and single-threaded before realizing that the answer was right in front of him. And so, Node.js was born, and JavaScript became a force to be reckoned with in the server world.
async模块
keep789的博客
08-09 692
async是一个异步处理模块，主要有三个方式： 串行无关联   async.series() 并行无关联  async.parallel() 串行有关联  async.waterfall() 他们的基本用法，建一个a的文件夹，在它下面打开命令窗口，npm init 创建package.json文件，之后安装依赖，npm i async -D 写一个异步流程的js文件如下 //yb.js...
【Node.js异步编程：回调、Promise与async/await详解及框架选型指南】
最新发布
weixin_74887700的博客
04-11 1968
本文深度解析Node.js异步编程的三大核心模式——回调、Promise与async/await，通过性能对比实测数据（QPS提升300%），结合电商系统实战案例，提供框架选型决策树及优化方案，助开发者实现高效代码设计。
js async
蜗牛在奔跑的博客
02-22 5104
JS中的async/await的用法和理解 1、首先需要理解async 和 await的基本含义 async 是一个修饰符，async 定义的函数会默认的返回一个Promise对象resolve的值，因此对async函数可以直接进行then操作,返回的值即为then方法的传入函数 复制代码 // 0. async基础用法测试 async function fun0() { console.log(1) return 1 } fun0().then( x => { con.
【JS】Async
qq_41298192的博客
07-17 1274
回调函数在函数内传一个函数，如果有结果了就触发封装一个异步的概念事件监听发布/订阅。
JS的BOM对象与执行机制
weixin_49115895的博客
12-09 251
一、何为BOM BOM（browser object model）浏览器对象模型 1、关于BOM 核心是window对象，所有的全局变量和全局函数都被归在了window上 2.BOM是 Browser Object Model的缩写，是浏览器对象模型 2、BOM的构成 2、window对象 window对象：BOM的核心对象是window，它表示浏览器的一个实例 在浏览器中，window对象有双重角色，它既是通过javascript访问浏览器窗口的一个接口，又是ECMAScript规定的Global
node.js(v16.16.0) 安装包
03-29
Node.js 是一个开源、跨平台的 JavaScript 运行环境，它让开发者可以在服务器端执行 JavaScript 代码。Node.js 使用了 Google V8 引擎，这个引擎是为 Chrome 浏览器设计的，因此 Node.js 具有高性能和高效性的特点。...
Node.js-async-await-nodejs的启动库
08-09
这个“Node.js-async-await-nodejs的启动库”可能是一个帮助开发者快速上手并理解如何在Node.js项目中使用`async/await`的资源包。 首先，我们要理解`async/await`的基础概念。`async`关键字用于定义一个异步函数，...
Node.js连接OpenGauss异步转同步封装
06-10
在IT行业中，Node.js是一种基于Chrome V8引擎的JavaScript运行环境，它以其高效的非阻塞I/O和事件驱动模型在服务器端编程中受到广泛应用。OpenGauss则是一款开源的关系型数据库管理系统，专为大规模数据处理设计，...
Node.js 的模块知识汇总
10-19
Node.js是基于Chrome V8引擎的JavaScript运行环境，它使得JavaScript可以运行在服务器端，执行异步输入输出操作而不会阻塞。Node.js中的模块系统是其一大特色，它为开发提供了极大的便利。在Node.js中，每个模块都有...
node.js12.22.12+npm6.14.4
07-29
Node.js 使用 V8 引擎，这个由 Google 开发的高性能 JavaScript 引擎为 Node.js 提供了强大的动力。版本 12.22.12 是 Node.js 的一个重要稳定版本，它包含了多项性能优化、错误修复和新特性的引入。 npm (Node ...
JS async 函数
热门推荐
fuchang的博客
11-06 1万+
async 函数 含义 ES2017 标准引入了 async 函数，使得异步操作变得更加方便。 async 函数是什么？一句话，它就是 Generator 函数的语法糖。 生成器 function* foo() { yield setTimeout(()=>{console.log("第一步耗时操作 开始执行")},1000) yield setTimeout(()=>{console.log("第二步耗时操作 执行中")},2000) yield setTimeout(
node.js的async模块
dtbk123的博客
06-08 452
node.js中有一个异步模块async，用于流程控制，下面就来看下 async.series([function(callback){console.log(1);setTimeout(()=>{ callback(null,'1') },1000)}, function(callback){console.log(2);setTimeout(()=>{callback(null,'2')},1000)}],(err,result)=>{ console.log(re
async 函数的含义和用法
阿利的技术积累
12-23 2259
一、终极解决 异步操作是 JavaScript 编程的麻烦事，麻烦到一直有人提出各种各样的方案，试图解决这个问题。 从最早的回调函数，到 Promise 对象，再到 Generator 函数，每次都有所改进，但又让人觉得不彻底。它们都有额外的复杂性，都需要理解抽象的底层运行机制。 异步I/O不就是读取一个文件吗，干嘛要搞得这么复杂？异步编程的最高境界，就是根本不用关心它是
JavaScript async函数
weixin_43078586的博客
12-20 774
async函数 async函数可能包含0个或者多个await表达式。 await表达式会暂停整个async函数的执行进程并出让其控制权，只有当其等待的基于promise的异步操作被兑现或被拒绝之后才会恢复进程。 promise的解决值会被当作该await表达式的返回值。 使用async / await关键字就可以在异步代码中使用普通的try / catch代码块。 async函数一定会返回一个promise对象。如果一个async函数的返回值看起来不是promise，那么它将会被隐式地包装在一个promi
JS的async/await
qq_40122602的博客
10-11 170
这个问题的关键在于，async 函数是怎么处理它的返回值的！ 我们当然希望它能直接通过 return 语句返回我们想要的值，但是如果真是这样，似乎就没 await 什么事了。所以，写段代码来试试，看它到底会返回什么： async function testAsync() { return “hello async”; } const result = testAsync(); console.log(result); 看输出的是一个 Promise 对象。 所以，async 函数返回的是一个 Promise
JavaScript学习之async函数
weixin_45820190的博客
03-03 5701
JavaScript中的async函数
js中的async/await
曹定栓的博客
09-21 3450
js中的async/await
【JS async 详解】
前端-CV全粘工程师
07-26 398
在上面的代码中，getUserData函数使用async关键字标记为异步函数，并在内部使用await关键字等待fetch操作完成。fetch返回Promise对象，并使用await等待Promise对象的结果，然后解析响应的JSON内容。async函数是一个返回Promise对象的函数，可以通过await等待异步操作的结果。由于async/await使用Promise来管理异步操作，因此我们必须使用try/catch块来捕获Promise的拒绝（rejected）状态。
node.js使用async await
01-03
### 如何在 Node.js 中使用 `async`/`await` 进行异步操作 #### 使用场景与优势 为了提高代码的可读性和简化错误处理，在 Node.js 开发中采用 `Promises` 和 `async`/`await` 来管理异步流程是一种现代化的做法[^1]。这种方式让开发者能够写出更加直观易懂的异步逻辑。 #### 基本语法介绍 当涉及到具体的实现细节时，`async` 关键字用于定义一个返回 Promise 的函数；而 `await` 则用来等待这个 promise 完成并获取其结果。需要注意的是，只有在一个被标记为 `async` 的函数内才能合法地使用 `await` 表达式来暂停执行直到对应的异步任务完成[^2]。 #### 实践案例分析 下面给出一段简单的例子展示如何利用这些特性： ```javascript // 导入必要的模块 const fs = require('fs').promises; /// 创建一个异步函数 readContentFromFile async function readContentFromFile(filePath) { try { const data = await fs.readFile(filePath, 'utf8'); // 等待文件读取完成 console.log(data); // 输出文件内容到控制台 } catch (error) { // 处理可能发生的异常情况 console.error(`Error reading file from ${filePath}:`, error.message); } } readContentFromFile('./example.txt'); ``` 这段程序展示了怎样通过 `async`/`await` 结合内置于 Node.js 文件系统的 promises API (`require('fs').promises`) 来优雅地处理 I/O 操作中的不确定性因素[^3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值