nodejs中async都有哪些常用方法？分别怎么用？

封面图 • 2025-10-16 • nodejs

在 Node.js 中，`async` 是一个非常常用的库，用于处理异步操作。它提供了一系列的函数来简化异步代码的编写，特别是当需要处理多个异步任务时，可以避免“回调地狱”（Callback Hell），使代码更清晰、更易维护。

以下是 `async` 模块中一些**常用的方法及其用法**：

---

## ✅ 1. `async.series(tasks, callback)`

按顺序执行多个异步任务，每个任务完成后才执行下一个。

### 语法：
```js
async.series({
    task1: function(callback) { ... },
    task2: function(callback) { ... }
}, function(err, results) {
    // 所有任务完成后的回调
});
```

### 示例：
```js
const async = require('async');

async.series({
    first: function(callback) {
        setTimeout(() => {
            console.log('First task done');
            callback(null, 'first result');
        }, 1000);
    },
    second: function(callback) {
        setTimeout(() => {
            console.log('Second task done');
            callback(null, 'second result');
        }, 500);
    }
}, function(err, results) {
    console.log('All tasks done:', results);
});
```

---

## ✅ 2. `async.parallel(tasks, callback)`

并行执行多个异步任务，不关心顺序。

### 语法：
```js
async.parallel({
    task1: function(callback) { ... },
    task2: function(callback) { ... }
}, function(err, results) {
    // 所有任务完成后的回调
});
```

### 示例：
```js
async.parallel({
    first: function(callback) {
        setTimeout(() => {
            callback(null, 'first result');
        }, 1000);
    },
    second: function(callback) {
        setTimeout(() => {
            callback(null, 'second result');
        }, 500);
    }
}, function(err, results) {
    console.log('All tasks done:', results);
});
```

---

## ✅ 3. `async.waterfall(tasks, callback)`

将一系列函数串联起来，前一个函数的结果作为下一个函数的参数。

### 语法：
```js
async.waterfall([
    function(callback) { ... },
    function(arg1, callback) { ... },
    function(arg2, callback) { ... }
], function(err, result) {
    // 最终结果
});
```

### 示例：
```js
async.waterfall([
    function(callback) {
        callback(null, 'one', 'two');
    },
    function(arg1, arg2, callback) {
        console.log('arg1:', arg1); // 'one'
        console.log('arg2:', arg2); // 'two'
        callback(null, 'three');
    },
    function(arg1, callback) {
        console.log('arg1:', arg1); // 'three'
        callback(null, 'done');
    }
], function(err, result) {
    console.log('Final result:', result); // 'done'
});
```

---

## ✅ 4. `async.map(coll, iteratee, callback)`

对集合中的每个元素进行异步处理，并返回结果数组。

### 语法：
```js
async.map([1, 2, 3], function(item, callback) {
    // 异步处理
    callback(null, item * 2);
}, function(err, results) {
    // 处理结果
});
```

### 示例：
```js
async.map([1, 2, 3], function(num, callback) {
    setTimeout(() => {
        callback(null, num * 2);
    }, 100);
}, function(err, results) {
    console.log(results); // [2, 4, 6]
});
```

---

## ✅ 5. `async.each(coll, iteratee, callback)`

对集合中的每个元素进行异步处理，但不等待所有完成。

### 语法：
```js
async.each([1, 2, 3], function(item, callback) {
    // 异步处理
    callback();
}, function(err) {
    // 所有处理完成
});
```

### 示例：
```js
async.each([1, 2, 3], function(num, callback) {
    setTimeout(() => {
        console.log('Processing:', num);
        callback();
    }, 100);
}, function(err) {
    console.log('All items processed.');
});
```

---

## ✅ 6. `async.auto(tasks, [callback])`

自动执行依赖关系的任务，适用于任务之间有依赖关系的情况。

### 语法：
```js
async.auto({
    task1: function(callback) { ... },
    task2: ['task1', function(callback, results) { ... }],
}, function(err, results) {
    // 所有任务完成后的回调
});
```

### 示例：
```js
async.auto({
    task1: function(callback) {
        setTimeout(() => {
            callback(null, 'result of task1');
        }, 100);
    },
    task2: ['task1', function(callback, results) {
        console.log('task1 result:', results.task1);
        callback(null, 'result of task2');
    }]
}, function(err, results) {
    console.log('Final results:', results);
});
```

---

## ✅ 7. `async.retry(times, task, callback)`

尝试执行一个异步任务，失败后重试指定次数。

### 语法：
```js
async.retry(3, function(callback) {
    // 异步任务
    if (Math.random() > 0.5) {
        callback(null, 'success');
    } else {
        callback(new Error('retry'));
    }
}, function(err, result) {
    // 处理结果
});
```

---

## ✅ 8. `async.apply(fn, args...)`

固定函数的部分参数，返回一个新函数。

### 语法：
```js
var func = async.apply(myFunction, 'arg1', 'arg2');
func(callback);
```

### 示例：
```js
function myFunction(a, b, callback) {
    callback(null, a + b);
}

var add = async.apply(myFunction, 1, 2);

add(function(err, result) {
    console.log(result); // 3
});
```

---

## ✅ 9. `async.reflect(fn)`

包装一个异步函数，使其返回一个包含错误和结果的对象。

### 语法：
```js
var wrapped = async.reflect(myAsyncFunction);
wrapped(args..., callback);
```

### 示例：
```js
function myAsyncFunction(a, callback) {
    setTimeout(() => {
        callback(null, a * 2);
    }, 100);
}

var wrapped = async.reflect(myAsyncFunction);

wrapped(5, function(err, result) {
    console.log('Error:', err);      // null
    console.log('Result:', result);  // 10
});
```

---

## ✅ 10. `async.await(fn, ...args)`

这是一个较新的方法（Node.js v15+ 支持），用来等待异步函数返回结果。

### 示例：
```js
const fs = require('fs').promises;

async function readFiles() {
    const data = await fs.readFile('file.txt', 'utf-8');
    console.log(data);
}
```

> 注意：`async/await` 是 JavaScript 原生支持的，不是 `async` 库的功能，但在异步编程中经常与 `async` 库结合使用。

---

## ✅ 总结

| 方法 | 用途 |
|------|------|
| `series` | 顺序执行多个异步任务 |
| `parallel` | 并行执行多个异步任务 |
| `waterfall` | 链式调用，传递结果 |
| `map` | 对集合中的每个元素进行异步处理 |
| `each` | 遍历集合，异步处理每个元素 |
| `auto` | 自动处理任务依赖 |
| `retry` | 失败后重试 |
| `apply` | 固定函数参数 |
| `reflect` | 包装函数，捕获错误和结果 |
| `await` | 原生异步等待（非 `async` 库） |

---

如果你是初学者，建议从 `async.series` 和 `async.parallel` 开始，逐步了解其他高级功能。

是否需要我帮你写一个完整的例子或演示某个特定方法？