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

在 Node.js 中，`async` 是一个非常常用的库（由 caolan 编写），用于处理异步操作，特别是在处理多个异步任务时，可以更优雅地控制流程。它提供了许多实用的函数来简化异步代码。

---

## 🧩 一、常用 `async` 方法

以下是一些 `async` 库中常用的函数及其用法：

---

### 1. `async.series(tasks, [callback])`

**作用：** 按顺序执行多个异步函数，每个函数完成后调用下一个。

```js
const async = require('async');

async.series([
    function (callback) {
        setTimeout(() => {
            console.log('Task 1 done');
            callback(null, 'result1');
        }, 100);
    },
    function (callback) {
        setTimeout(() => {
            console.log('Task 2 done');
            callback(null, 'result2');
        }, 50);
    }
], function (err, results) {
    if (err) {
        console.error(err);
    } else {
        console.log('All tasks done:', results);
    }
});
```

> ✅ **注意：** 所有任务都按顺序执行，前一个完成才会执行下一个。

---

### 2. `async.parallel(tasks, [callback])`

**作用：** 并行执行多个异步函数，最后统一回调。

```js
async.parallel([
    function (callback) {
        setTimeout(() => {
            console.log('Parallel Task 1 done');
            callback(null, 'result1');
        }, 100);
    },
    function (callback) {
        setTimeout(() => {
            console.log('Parallel Task 2 done');
            callback(null, 'result2');
        }, 50);
    }
], function (err, results) {
    if (err) {
        console.error(err);
    } else {
        console.log('All parallel tasks done:', results);
    }
});
```

> ✅ **注意：** 所有任务同时开始，结果按原顺序返回。

---

### 3. `async.waterfall(tasks, [callback])`

**作用：** 按顺序执行异步函数，将前一个函数的结果传递给下一个函数。

```js
async.waterfall([
    function (callback) {
        callback(null, 'first', 'second');
    },
    function (arg1, arg2, callback) {
        console.log(`Received: ${arg1}, ${arg2}`);
        callback(null, 'third');
    }
], function (err, result) {
    if (err) {
        console.error(err);
    } else {
        console.log('Final result:', result);
    }
});
```

> ✅ **注意：** 上一个函数的输出作为下一个函数的输入。

---

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

**作用：** 对集合中的每个元素进行异步处理，返回处理后的数组。

```js
async.map([1, 2, 3], function (num, callback) {
    setTimeout(() => {
        callback(null, num * 2);
    }, 100);
}, function (err, results) {
    if (err) {
        console.error(err);
    } else {
        console.log('Map results:', results); // [2, 4, 6]
    }
});
```

---

### 5. `async.filter(coll, iteratee, [callback])`

**作用：** 对集合中的每个元素进行异步判断，筛选出符合条件的元素。

```js
async.filter([1, 2, 3, 4], function (num, callback) {
    setTimeout(() => {
        callback(null, num % 2 === 0);
    }, 100);
}, function (err, results) {
    if (err) {
        console.error(err);
    } else {
        console.log('Filtered results:', results); // [2, 4]
    }
});
```

---

### 6. `async.each(coll, iteratee, [callback])`

**作用：** 遍历集合中的每个元素并执行异步函数。

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

---

### 7. `async.forEachSeries(coll, iteratee, [callback])`

**作用：** 顺序遍历集合，每个元素处理完再处理下一个。

```js
async.forEachSeries([1, 2, 3], function (num, callback) {
    setTimeout(() => {
        console.log('Processing in series:', num);
        callback();
    }, 100);
}, function (err) {
    if (err) {
        console.error(err);
    } else {
        console.log('All items processed in series.');
    }
});
```

---

### 8. `async.whilst(test, fn, [callback])`

**作用：** 在条件满足时循环执行异步函数。

```js
let count = 0;
async.whilst(
    function () { return count < 3; },
    function (callback) {
        setTimeout(() => {
            console.log('Count:', count++);
            callback();
        }, 100);
    },
    function (err) {
        if (err) {
            console.error(err);
        } else {
            console.log('Loop finished.');
        }
    }
);
```

---

### 9. `async.until(test, fn, [callback])`

**作用：** 当条件不满足时循环执行异步函数。

```js
let count = 0;
async.until(
    function () { return count >= 3; },
    function (callback) {
        setTimeout(() => {
            console.log('Count:', count++);
            callback();
        }, 100);
    },
    function (err) {
        if (err) {
            console.error(err);
        } else {
            console.log('Loop finished.');
        }
    }
);
```

---

### 10. `async.apply(fn, ...args)`

**作用：** 将函数绑定参数，返回一个新函数。

```js
function greet(name, greeting) {
    console.log(`${greeting}, ${name}!`);
}

const sayHello = async.apply(greet, 'Alice', 'Hello');
sayHello(); // 输出: Hello, Alice!
```

---

## 🧠 总结

| 方法 | 用途 |
|------|------|
| `series` | 顺序执行多个异步任务 |
| `parallel` | 并行执行多个异步任务 |
| `waterfall` | 顺序执行，前一个结果传给下一个 |
| `map` | 对集合中的每个元素异步处理 |
| `filter` | 筛选集合中符合条件的元素 |
| `each` | 遍历集合，执行异步函数 |
| `forEachSeries` | 顺序遍历集合 |
| `whilst` | 条件满足时循环执行 |
| `until` | 条件不满足时循环执行 |
| `apply` | 绑定函数参数 |

---

## 💡 提示

- `async` 库非常适合处理复杂的异步流程控制。
- 如果你使用的是 ES6+，也可以考虑使用 `Promise` + `async/await`，它们在现代 Node.js 中已经非常成熟。
- `async` 仍然在一些老项目中广泛使用，特别是需要兼容旧代码或复杂流程控制时。

---

如果你需要我给出一个完整的 `async` 示例项目结构或者和 `Promise` 的对比，也欢迎继续问我 😊