方法

(static) concat(coll, iteratee, callbackopt) → {Promise}

import concat from 'async/concat';

别名：

• flatMap

参数：

返回：

类型

Promise

示例

async.concat(['dir1','dir2','dir3'], fs.readdir, function(err, files) {
    // 现在 files 是在 3 个目录中已存在的文件名
});

源码：

• concat.js, line 4

(static) concatLimit(coll, limit, iteratee, callbackopt) → {Promise}

import concatLimit from 'async/concatLimit';

别名：

• flatMapLimit

参数：

返回：

• 忽略 callback 时，会返回一个 promise

  类型

  Promise

• A Promise, if no callback is passed

源码：

• concatLimit.js, line 5

参见：

• async.concat

(static) concatSeries(coll, iteratee, callbackopt) → {Promise}

import concatSeries from 'async/concatSeries';

别名：

• flatMapSeries

参数：

返回：

类型

Promise

源码：

• concatSeries.js, line 4

参见：

• async.concat

(static) detect(coll, iteratee, callbackopt)

import detect from 'async/detect';

别名：

• find

参数：

返回：

示例

async.detect(['file1','file2','file3'], function(filePath, callback) {
    fs.access(filePath, function(err) {
        callback(null, !err)
    });
}, function(err, result) {
    // result now equals the first file in the list that exists
});

源码：

• detect.js, line 5

(static) detectLimit(coll, limit, iteratee, callbackopt)

import detectLimit from 'async/detectLimit';

别名：

• findLimit

参数：

返回：

源码：

• detectLimit.js, line 5

参见：

• async.detect

(static) detectSeries(coll, iteratee, callbackopt)

import detectSeries from 'async/detectSeries';

别名：

• findSeries

参数：

返回：

源码：

• detectSeries.js, line 5

参见：

• async.detect

(static) each(coll, iteratee, callbackopt) → {Promise}

import each from 'async/each';

别名：

• forEach

参数：

返回：

类型

Promise

示例

// 假设 openFiles 是文件名数组，saveFile 是保存文件修改内容的函数：

async.each(openFiles, saveFile, function(err){
  // 如果任意一次保存产生一个 error，这个 err 等于那个 error
});

// 假设 openFiles 是文件名数组
async.each(openFiles, function(file, callback) {

    // 在此执行文件操作
    console.log('Processing file ' + file);

    if( file.length > 32 ) {
      console.log('This file name is too long');
      callback('File name too long');
    } else {
      // 在此执行文件操作
      console.log('File processed');
      callback();
    }
}, function(err) {
    //  如果任意一次文件处理产生一个 error，这个 err 等于那个 error
    if( err ) {
      // 只要有一次迭代产生 error，
      // 所有的处理都会立即停止。
      console.log('A file failed to process');
    } else {
      console.log('All files have been processed successfully');
    }
});

源码：

• each.js, line 6

(static) eachLimit(coll, limit, iteratee, callbackopt) → {Promise}

import eachLimit from 'async/eachLimit';

别名：

• forEachLimit

参数：

返回：

类型

Promise

源码：

• eachLimit.js, line 6

参见：

• async.each

(static) eachOf(coll, iteratee, callbackopt) → {Promise}

import eachOf from 'async/eachOf';

别名：

• forEachOf

参数：

返回：

类型

Promise

示例

var obj = {dev: "/dev.json", test: "/test.json", prod: "/prod.json"};
var configs = {};

async.forEachOf(obj, function (value, key, callback) {
    fs.readFile(__dirname + value, "utf8", function (err, data) {
        if (err) return callback(err);
        try {
            configs[key] = JSON.parse(data);
        } catch (e) {
            return callback(e);
        }
        callback();
    });
}, function (err) {
    if (err) console.error(err.message);
    // configs 现在是 JSON 数据的映射
    doSomethingWith(configs);
});

源码：

• eachOf.js, line 42

参见：

• async.each

(static) eachOfLimit(coll, limit, iteratee, callbackopt) → {Promise}

import eachOfLimit from 'async/eachOfLimit';

别名：

• forEachOfLimit

参数：

返回：

类型

Promise

源码：

• eachOfLimit.js, line 5

参见：

• async.eachOf

(static) eachOfSeries(coll, iteratee, callbackopt) → {Promise}

import eachOfSeries from 'async/eachOfSeries';

别名：

• forEachOfSeries

参数：

返回：

类型

Promise

源码：

• eachOfSeries.js, line 4

参见：

• async.eachOf

(static) eachSeries(coll, iteratee, callbackopt) → {Promise}

import eachSeries from 'async/eachSeries';

别名：

• forEachSeries

参数：

返回：

类型

Promise

源码：

• eachSeries.js, line 4

参见：

• async.each

(static) every(coll, iteratee, callbackopt) → {Promise}

import every from 'async/every';

别名：

• all

参数：

返回：

类型

Promise

示例

async.every(['file1','file2','file3'], function(filePath, callback) {
    fs.access(filePath, function(err) {
        callback(null, !err)
    });
}, function(err, result) {
    // if result is true then every file exists
});

源码：

• every.js, line 5

(static) everyLimit(coll, limit, iteratee, callbackopt) → {Promise}

import everyLimit from 'async/everyLimit';

别名：

• allLimit

参数：

返回：

类型

Promise

源码：

• everyLimit.js, line 5

参见：

• async.every

(static) everySeries(coll, iteratee, callbackopt) → {Promise}

import everySeries from 'async/everySeries';

别名：

• allSeries

参数：

返回：

类型

Promise

源码：

• everySeries.js, line 5

参见：

• async.every

(static) filter(coll, iteratee, callbackopt) → {Promise}

import filter from 'async/filter';

别名：

• select

参数：

返回：

类型

Promise

示例

async.filter(['file1','file2','file3'], function(filePath, callback) {
    fs.access(filePath, function(err) {
        callback(null, !err)
    });
}, function(err, results) {
    // results now equals an array of the existing files
});

源码：

• filter.js, line 5

(static) filterLimit(coll, limit, iteratee, callbackopt) → {Promise}

import filterLimit from 'async/filterLimit';

别名：

• selectLimit

参数：

返回：

类型

Promise

源码：

• filterLimit.js, line 5

参见：

• async.filter

(static) filterSeries(coll, iteratee, callbackopt) → {Promise}

import filterSeries from 'async/filterSeries';

别名：

• selectSeries

参数：

返回：

类型

Promise

源码：

• filterSeries.js, line 5

参见：

• async.filter

(static) groupBy(coll, iteratee, callbackopt) → {Promise}

import groupBy from 'async/groupBy';

参数：

返回：

类型

Promise

示例

async.groupBy(['userId1', 'userId2', 'userId3'], function(userId, callback) {
    db.findById(userId, function(err, user) {
        if (err) return callback(err);
        return callback(null, user.age);
    });
}, function(err, result) {
    // result is object containing the userIds grouped by age
    // e.g. { 30: ['userId1', 'userId3'], 42: ['userId2']};
});

源码：

• groupBy.js, line 3

(static) groupByLimit(coll, limit, iteratee, callbackopt) → {Promise}

import groupByLimit from 'async/groupByLimit';

参数：

返回：

类型

Promise

源码：

• groupByLimit.js, line 5

参见：

• async.groupBy

(static) groupBySeries(coll, iteratee, callbackopt) → {Promise}

import groupBySeries from 'async/groupBySeries';

参数：

返回：

类型

Promise

源码：

• groupBySeries.js, line 3

参见：

• async.groupBy

(static) map(coll, iteratee, callbackopt) → {Promise}

import map from 'async/map';

参数：

返回：

类型

Promise

示例

async.map(['file1','file2','file3'], fs.stat, function(err, results) {
    // results is now an array of stats for each file
});

源码：

• map.js, line 5

(static) mapLimit(coll, limit, iteratee, callbackopt) → {Promise}

import mapLimit from 'async/mapLimit';

参数：

返回：

类型

Promise

源码：

• mapLimit.js, line 5

参见：

• async.map

(static) mapSeries(coll, iteratee, callbackopt) → {Promise}

import mapSeries from 'async/mapSeries';

参数：

返回：

类型

Promise

源码：

• mapSeries.js, line 5

参见：

• async.map

(static) mapValues(obj, iteratee, callbackopt) → {Promise}

import mapValues from 'async/mapValues';

参数：

返回：

类型

Promise

示例

async.mapValues({
    f1: 'file1',
    f2: 'file2',
    f3: 'file3'
}, function (file, key, callback) {
  fs.stat(file, callback);
}, function(err, result) {
    // result is now a map of stats for each file, e.g.
    // {
    //     f1: [stats for file1],
    //     f2: [stats for file2],
    //     f3: [stats for file3]
    // }
});

源码：

• mapValues.js, line 3

(static) mapValuesLimit(obj, limit, iteratee, callbackopt) → {Promise}

import mapValuesLimit from 'async/mapValuesLimit';

参数：

返回：

类型

Promise

源码：

• mapValuesLimit.js, line 6

参见：

• async.mapValues

(static) mapValuesSeries(obj, iteratee, callbackopt) → {Promise}

import mapValuesSeries from 'async/mapValuesSeries';

参数：

返回：

类型

Promise

源码：

• mapValuesSeries.js, line 3

参见：

• async.mapValues

(static) reduce(coll, memo, iteratee, callbackopt) → {Promise}

import reduce from 'async/reduce';

别名：

• foldl

参数：

返回：

类型

Promise

示例

async.reduce([1,2,3], 0, function(memo, item, callback) {
    // pointless async:
    process.nextTick(function() {
        callback(null, memo + item)
    });
}, function(err, result) {
    // result is now equal to the last value of memo, which is 6
});

源码：

• reduce.js, line 6

(static) reduceRight(array, memo, iteratee, callbackopt) → {Promise}

import reduceRight from 'async/reduceRight';

别名：

• foldr

参数：

返回：

类型

Promise

源码：

• reduceRight.js, line 3

参见：

• async.reduce

(static) reject(coll, iteratee, callbackopt) → {Promise}

import reject from 'async/reject';

参数：

返回：

类型

Promise

示例

async.reject(['file1','file2','file3'], function(filePath, callback) {
    fs.access(filePath, function(err) {
        callback(null, !err)
    });
}, function(err, results) {
    // results now equals an array of missing files
    createFiles(results);
});

源码：

• reject.js, line 5

参见：

• async.filter

(static) rejectLimit(coll, limit, iteratee, callbackopt) → {Promise}

import rejectLimit from 'async/rejectLimit';

参数：

返回：

类型

Promise

源码：

• rejectLimit.js, line 4

参见：

• async.reject

(static) rejectSeries(coll, iteratee, callbackopt) → {Promise}

import rejectSeries from 'async/rejectSeries';

参数：

返回：

类型

Promise

源码：

• rejectSeries.js, line 5

参见：

• async.reject

(static) some(coll, iteratee, callbackopt) → {Promise}

import some from 'async/some';

别名：

• any

参数：

返回：

类型

Promise

示例

async.some(['file1','file2','file3'], function(filePath, callback) {
    fs.access(filePath, function(err) {
        callback(null, !err)
    });
}, function(err, result) {
    // if result is true then at least one of the files exists
});

源码：

• some.js, line 5

(static) someLimit(coll, limit, iteratee, callbackopt) → {Promise}

import someLimit from 'async/someLimit';

别名：

• anyLimit

参数：

返回：

类型

Promise

源码：

• someLimit.js, line 5

参见：

• async.some

(static) someSeries(coll, iteratee, callbackopt) → {Promise}

import someSeries from 'async/someSeries';

别名：

• anySeries

参数：

返回：

类型

Promise

源码：

• someSeries.js, line 5

参见：

• async.some

(static) sortBy(coll, iteratee, callback) → {Promise}

import sortBy from 'async/sortBy';

参数：

返回：

类型

Promise

示例

async.sortBy(['file1','file2','file3'], function(file, callback) {
    fs.stat(file, function(err, stats) {
        callback(err, stats.mtime);
    });
}, function(err, results) {
    // results is now the original array of files sorted by
    // modified date
});

// By modifying the callback parameter the
// sorting order can be influenced:

// ascending order
async.sortBy([1,9,3,5], function(x, callback) {
    callback(null, x);
}, function(err,result) {
    // result callback
});

// descending order
async.sortBy([1,9,3,5], function(x, callback) {
    callback(null, x*-1);    //<- x*-1 instead of x, turns the order around
}, function(err,result) {
    // result callback
});

源码：

• sortBy.js, line 5

(static) transform(coll, accumulatoropt, iteratee, callbackopt) → {Promise}

import transform from 'async/transform';

参数：

返回：

类型

Promise

示例

async.transform([1,2,3], function(acc, item, index, callback) {
    // pointless async:
    process.nextTick(function() {
        acc[index] = item * 2
        callback(null)
    });
}, function(err, result) {
    // result is now equal to [2, 4, 6]
});

async.transform({a: 1, b: 2, c: 3}, function (obj, val, key, callback) {
    setImmediate(function () {
        obj[key] = val * 2;
        callback();
    })
}, function (err, result) {
    // result is equal to {a: 2, b: 4, c: 6}
})

源码：

• transform.js, line 6

方法

(static) applyEach(fns, …argsopt, callbackopt) → {AsyncFunction}

import applyEach from 'async/applyEach';

参数：

返回：

类型

AsyncFunction

示例

const appliedFn = async.applyEach([enableSearch, updateSchema], 'bucket')

appliedFn((err, results) => {
    // results[0] is the results for `enableSearch`
    // results[1] is the results for `updateSchema`
});

// partial application example:
async.each(
    buckets,
    async (bucket) => async.applyEach([enableSearch, updateSchema], bucket)(),
    callback
);

源码：

• applyEach.js, line 4

(static) applyEachSeries(fns, …argsopt, callbackopt) → {AsyncFunction}

import applyEachSeries from 'async/applyEachSeries';

参数：

返回：

类型

AsyncFunction

源码：

• applyEachSeries.js, line 4

参见：

• async.applyEach

(static) auto(tasks, concurrencyopt, callbackopt) → {Promise}

import auto from 'async/auto';

参数：

返回：

类型

Promise

示例

async.auto({
    // this function will just be passed a callback
    readData: async.apply(fs.readFile, 'data.txt', 'utf-8'),
    showData: ['readData', function(results, cb) {
        // results.readData is the file's contents
        // ...
    }]
}, callback);

async.auto({
    get_data: function(callback) {
        console.log('in get_data');
        // async code to get some data
        callback(null, 'data', 'converted to array');
    },
    make_folder: function(callback) {
        console.log('in make_folder');
        // async code to create a directory to store a file in
        // this is run at the same time as getting the data
        callback(null, 'folder');
    },
    write_file: ['get_data', 'make_folder', function(results, callback) {
        console.log('in write_file', JSON.stringify(results));
        // once there is some data and the directory exists,
        // write the data to a file in the directory
        callback(null, 'filename');
    }],
    email_link: ['write_file', function(results, callback) {
        console.log('in email_link', JSON.stringify(results));
        // once the file is written let's email a link to it...
        // results.write_file contains the filename returned by write_file.
        callback(null, {'file':results.write_file, 'email':'user@example.com'});
    }]
}, function(err, results) {
    console.log('err = ', err);
    console.log('results = ', results);
});

源码：

• auto.js, line 6

(static) autoInject(tasks, callbackopt) → {Promise}

import autoInject from 'async/autoInject';

参数：

返回：

类型

Promise

示例

//  The example from `auto` can be rewritten as follows:
async.autoInject({
    get_data: function(callback) {
        // async code to get some data
        callback(null, 'data', 'converted to array');
    },
    make_folder: function(callback) {
        // async code to create a directory to store a file in
        // this is run at the same time as getting the data
        callback(null, 'folder');
    },
    write_file: function(get_data, make_folder, callback) {
        // once there is some data and the directory exists,
        // write the data to a file in the directory
        callback(null, 'filename');
    },
    email_link: function(write_file, callback) {
        // once the file is written let's email a link to it...
        // write_file contains the filename returned by write_file.
        callback(null, {'file':write_file, 'email':'user@example.com'});
    }
}, function(err, results) {
    console.log('err = ', err);
    console.log('email_link = ', results.email_link);
});

// If you are using a JS minifier that mangles parameter names, `autoInject`
// will not work with plain functions, since the parameter names will be
// collapsed to a single letter identifier.  To work around this, you can
// explicitly specify the names of the parameters your task function needs
// in an array, similar to Angular.js dependency injection.

// This still has an advantage over plain `auto`, since the results a task
// depends on are still spread into arguments.
async.autoInject({
    //...
    write_file: ['get_data', 'make_folder', function(get_data, make_folder, callback) {
        callback(null, 'filename');
    }],
    email_link: ['write_file', function(write_file, callback) {
        callback(null, {'file':write_file, 'email':'user@example.com'});
    }]
    //...
}, function(err, results) {
    console.log('err = ', err);
    console.log('email_link = ', results.email_link);
});

源码：

• autoInject.js, line 25

参见：

• async.auto

(static) cargo(worker, payloadopt) → {QueueObject}

import cargo from 'async/cargo';

参数：

返回：

类型

QueueObject

示例

// create a cargo object with payload 2
var cargo = async.cargo(function(tasks, callback) {
    for (var i=0; i<tasks.length; i++) {
        console.log('hello ' + tasks[i].name);
    }
    callback();
}, 2);

// add some items
cargo.push({name: 'foo'}, function(err) {
    console.log('finished processing foo');
});
cargo.push({name: 'bar'}, function(err) {
    console.log('finished processing bar');
});
await cargo.push({name: 'baz'});
console.log('finished processing baz');

源码：

• cargo.js, line 3

参见：

• async.queue

(static) cargoQueue(worker, concurrencyopt, payloadopt) → {QueueObject}

import cargoQueue from 'async/cargoQueue';

参数：

返回：

类型

QueueObject

示例

// create a cargoQueue object with payload 2 and concurrency 2
var cargoQueue = async.cargoQueue(function(tasks, callback) {
    for (var i=0; i<tasks.length; i++) {
        console.log('hello ' + tasks[i].name);
    }
    callback();
}, 2, 2);

// add some items
cargoQueue.push({name: 'foo'}, function(err) {
    console.log('finished processing foo');
});
cargoQueue.push({name: 'bar'}, function(err) {
    console.log('finished processing bar');
});
cargoQueue.push({name: 'baz'}, function(err) {
    console.log('finished processing baz');
});
cargoQueue.push({name: 'boo'}, function(err) {
    console.log('finished processing boo');
});

源码：

• cargoQueue.js, line 3

参见：

• async.queue

• async.cargo

(static) compose(…functions) → {function}

import compose from 'async/compose';

参数：

返回：

类型

function

示例

function add1(n, callback) {
    setTimeout(function () {
        callback(null, n + 1);
    }, 10);
}

function mul3(n, callback) {
    setTimeout(function () {
        callback(null, n * 3);
    }, 10);
}

var add1mul3 = async.compose(mul3, add1);
add1mul3(4, function (err, result) {
    // result now equals 15
});

源码：

• compose.js, line 3

(static) doUntil(iteratee, test, callbackopt) → {Promise}

import doUntil from 'async/doUntil';

参数：

返回：

类型

Promise

源码：

• doUntil.js, line 4

参见：

• async.doWhilst

(static) doWhilst(iteratee, test, callbackopt) → {Promise}

import doWhilst from 'async/doWhilst';

参数：

返回：

类型

Promise

源码：

• doWhilst.js, line 5

参见：

• async.whilst

(static) forever(fn, errbackopt) → {Promise}

import forever from 'async/forever';

参数：

返回：

类型

Promise

示例

async.forever(
    function(next) {
        // next is suitable for passing to things that need a callback(err [, whatever]);
        // it will result in this function being called again.
    },
    function(err) {
        // if next is called with a value in its first parameter, it will appear
        // in here as 'err', and execution will stop.
    }
);

源码：

• forever.js, line 6

(static) parallel(tasks, callbackopt) → {Promise}

import parallel from 'async/parallel';

参数：

返回：

类型

Promise

示例

async.parallel([
    function(callback) {
        setTimeout(function() {
            callback(null, 'one');
        }, 200);
    },
    function(callback) {
        setTimeout(function() {
            callback(null, 'two');
        }, 100);
    }
],
// optional callback
function(err, results) {
    // the results array will equal ['one','two'] even though
    // the second function had a shorter timeout.
});

// an example using an object instead of an array
async.parallel({
    one: function(callback) {
        setTimeout(function() {
            callback(null, 1);
        }, 200);
    },
    two: function(callback) {
        setTimeout(function() {
            callback(null, 2);
        }, 100);
    }
}, function(err, results) {
    // results is now equals to: {one: 1, two: 2}
});

源码：

• parallel.js, line 4

(static) parallelLimit(tasks, limit, callbackopt) → {Promise}

import parallelLimit from 'async/parallelLimit';

参数：

返回：

类型

Promise

源码：

• parallelLimit.js, line 4

参见：

• async.parallel

(static) priorityQueue(worker, concurrency) → {QueueObject}

import priorityQueue from 'async/priorityQueue';

参数：

返回：

类型

QueueObject

源码：

• priorityQueue.js, line 5

参见：

• async.queue

(static) queue(worker, concurrencyopt) → {QueueObject}

import queue from 'async/queue';

参数：

返回：

类型

QueueObject

示例

// 以并发数 2 创建队列对象
var q = async.queue(function(task, callback) {
    console.log('hello ' + task.name);
    callback();
}, 2);

// 指定 callback
q.drain(function() {
    console.log('all items have been processed');
});
// 或 await 至结束
await q.drain()

// 设置 error callback
q.error(function(err, task) {
    console.error('task experienced an error');
});

// 为队列添加任务
q.push({name: 'foo'}, function(err) {
    console.log('finished processing foo');
});
// callback 可忽略
q.push({name: 'bar'});

// 批量添加任务到队列
q.push([{name: 'baz'},{name: 'bay'},{name: 'bax'}], function(err) {
    console.log('finished processing item');
});

// 添加任务至队列的前排
q.unshift({name: 'bar'}, function (err) {
    console.log('finished processing bar');
});

源码：

• queue.js, line 77

(static) race(tasks, callback)

import race from 'async/race';

参数：

返回：

示例

async.race([
    function(callback) {
        setTimeout(function() {
            callback(null, 'one');
        }, 200);
    },
    function(callback) {
        setTimeout(function() {
            callback(null, 'two');
        }, 100);
    }
],
// main callback
function(err, result) {
    // the result will be equal to 'two' as it finishes earlier
});

源码：

• race.js, line 5

(static) retry(optsopt, task, callbackopt) → {Promise}

import retry from 'async/retry';

参数：

返回：

类型

Promise

示例

// The `retry` function can be used as a stand-alone control flow by passing
// a callback, as shown below:

// try calling apiMethod 3 times
async.retry(3, apiMethod, function(err, result) {
    // do something with the result
});

// try calling apiMethod 3 times, waiting 200 ms between each retry
async.retry({times: 3, interval: 200}, apiMethod, function(err, result) {
    // do something with the result
});

// try calling apiMethod 10 times with exponential backoff
// (i.e. intervals of 100, 200, 400, 800, 1600, ... milliseconds)
async.retry({
  times: 10,
  interval: function(retryCount) {
    return 50 * Math.pow(2, retryCount);
  }
}, apiMethod, function(err, result) {
    // do something with the result
});

// try calling apiMethod the default 5 times no delay between each retry
async.retry(apiMethod, function(err, result) {
    // do something with the result
});

// try calling apiMethod only when error condition satisfies, all other
// errors will abort the retry control flow and return to final callback
async.retry({
  errorFilter: function(err) {
    return err.message === 'Temporary error'; // only retry on a specific error
  }
}, apiMethod, function(err, result) {
    // do something with the result
});

// to retry individual methods that are not as reliable within other
// control flow functions, use the `retryable` wrapper:
async.auto({
    users: api.getUsers.bind(api),
    payments: async.retryable(3, api.getPayments.bind(api))
}, function(err, results) {
    // do something with the results
});

源码：

• retry.js, line 10

参见：

• async.retryable

(static) retryable(optsopt, task) → {AsyncFunction}

import retryable from 'async/retryable';

参数：

返回：

类型

AsyncFunction

示例

async.auto({
    dep1: async.retryable(3, getFromFlakyService),
    process: ["dep1", async.retryable(3, function (results, cb) {
        maybeProcessData(results.dep1, cb);
    })]
}, callback);

源码：

• retryable.js, line 6

参见：

• async.retry

(static) seq(…functions) → {function}

import seq from 'async/seq';

参数：

返回：

类型

function

示例

// Requires lodash (or underscore), express3 and dresende's orm2.
// Part of an app, that fetches cats of the logged user.
// This example uses `seq` function to avoid overnesting and error
// handling clutter.
app.get('/cats', function(request, response) {
    var User = request.models.User;
    async.seq(
        _.bind(User.get, User),  // 'User.get' has signature (id, callback(err, data))
        function(user, fn) {
            user.getCats(fn);      // 'getCats' has signature (callback(err, data))
        }
    )(req.session.user_id, function (err, cats) {
        if (err) {
            console.error(err);
            response.json({ status: 'error', message: err.message });
        } else {
            response.json({ status: 'ok', message: 'Cats found', data: cats });
        }
    });
});

源码：

• seq.js, line 5

参见：

• async.compose

(static) series(tasks, callbackopt) → {Promise}

import series from 'async/series';

参数：

返回：

类型

Promise

示例

async.series([
    function(callback) {
        // do some stuff ...
        callback(null, 'one');
    },
    function(callback) {
        // do some more stuff ...
        callback(null, 'two');
    }
],
// optional callback
function(err, results) {
    // results is now equal to ['one', 'two']
});

async.series({
    one: function(callback) {
        setTimeout(function() {
            callback(null, 1);
        }, 200);
    },
    two: function(callback){
        setTimeout(function() {
            callback(null, 2);
        }, 100);
    }
}, function(err, results) {
    // results is now equal to: {one: 1, two: 2}
});

源码：

• series.js, line 4

(static) times(n, iteratee, callback) → {Promise}

import times from 'async/times';

参数：

返回：

类型

Promise

示例

// Pretend this is some complicated async factory
var createUser = function(id, callback) {
    callback(null, {
        id: 'user' + id
    });
};

// generate 5 users
async.times(5, function(n, next) {
    createUser(n, function(err, user) {
        next(err, user);
    });
}, function(err, users) {
    // we should now have 5 users
});

源码：

• times.js, line 3

参见：

• async.map

(static) timesLimit(count, limit, iteratee, callback) → {Promise}

import timesLimit from 'async/timesLimit';

参数：

返回：

类型

Promise

源码：

• timesLimit.js, line 5

参见：

• async.times

(static) timesSeries(n, iteratee, callback) → {Promise}

import timesSeries from 'async/timesSeries';

参数：

返回：

类型

Promise

源码：

• timesSeries.js, line 3

参见：

• async.times

(static) tryEach(tasks, callbackopt) → {Promise}

import tryEach from 'async/tryEach';

参数：

返回：

类型

Promise

示例

async.tryEach([
    function getDataFromFirstWebsite(callback) {
        // Try getting the data from the first website
        callback(err, data);
    },
    function getDataFromSecondWebsite(callback) {
        // First website failed,
        // Try getting the data from the backup website
        callback(err, data);
    }
],
// optional callback
function(err, results) {
    Now do something with the data.
});

源码：

• tryEach.js, line 5

(static) until(test, iteratee, callbackopt) → {Promise}

import until from 'async/until';

参数：

返回：

类型

Promise

示例

const results = []
let finished = false
async.until(function test(cb) {
    cb(null, finished)
}, function iter(next) {
    fetchPage(url, (err, body) => {
        if (err) return next(err)
        results = results.concat(body.objects)
        finished = !!body.next
        next(err)
    })
}, function done (err) {
    // all pages have been fetched
})

源码：

• until.js, line 4

参见：

• async.whilst

(static) waterfall(tasks, callbackopt)

import waterfall from 'async/waterfall';

参数：

返回：

示例

async.waterfall([
    function(callback) {
        callback(null, 'one', 'two');
    },
    function(arg1, arg2, callback) {
        // arg1 now equals 'one' and arg2 now equals 'two'
        callback(null, 'three');
    },
    function(arg1, callback) {
        // arg1 now equals 'three'
        callback(null, 'done');
    }
], function (err, result) {
    // result now equals 'done'
});

// Or, with named functions:
async.waterfall([
    myFirstFunction,
    mySecondFunction,
    myLastFunction,
], function (err, result) {
    // result now equals 'done'
});
function myFirstFunction(callback) {
    callback(null, 'one', 'two');
}
function mySecondFunction(arg1, arg2, callback) {
    // arg1 now equals 'one' and arg2 now equals 'two'
    callback(null, 'three');
}
function myLastFunction(arg1, callback) {
    // arg1 now equals 'three'
    callback(null, 'done');
}

源码：

• waterfall.js, line 7

(static) whilst(test, iteratee, callbackopt) → {Promise}

import whilst from 'async/whilst';

参数：

返回：

类型

Promise

示例

var count = 0;
async.whilst(
    function test(cb) { cb(null, count < 5); },
    function iter(callback) {
        count++;
        setTimeout(function() {
            callback(null, count);
        }, 1000);
    },
    function (err, n) {
        // 5 seconds have passed, n = 5
    }
);

源码：

• whilst.js, line 5

类型定义

QueueObject

import queue from 'async/queue';

类型：

• Iterable

属性：

源码：

• queue.js, line 4

示例：

const q = async.queue(worker, 2)
q.push(item1)
q.push(item2)
q.push(item3)
// queue 是可迭代的，展开成 array 后检测
const items = [...q] // [item1, item2, item3]
// 或使用 for of
for (let item of q) {
    console.log(item)
}

q.drain(() => {
    console.log('all done')
})
// 或
await q.drain()

方法

(static) apply(fn) → {function}

import apply from 'async/apply';

参数：

返回：

类型

function

示例

// using apply
async.parallel([
    async.apply(fs.writeFile, 'testfile1', 'test1'),
    async.apply(fs.writeFile, 'testfile2', 'test2')
]);


// the same process without using apply
async.parallel([
    function(callback) {
        fs.writeFile('testfile1', 'test1', callback);
    },
    function(callback) {
        fs.writeFile('testfile2', 'test2', callback);
    }
]);

// It's possible to pass any number of additional arguments when calling the
// continuation:

node> var fn = async.apply(sys.puts, 'one');
node> fn('two', 'three');
one
two
three

源码：

• apply.js, line 1

(static) asyncify(func) → {AsyncFunction}

import asyncify from 'async/asyncify';

别名：

• wrapSync

参数：

返回：

类型

AsyncFunction

示例

// 传入常规同步函数
async.waterfall([
    async.apply(fs.readFile, filename, "utf8"),
    async.asyncify(JSON.parse),
    function (data, next) {
        // data 是解析后的 text
        // 若出现错误，会被捕获。
    }
], callback);

// 传入返回 promise 的函数
async.waterfall([
    async.apply(fs.readFile, filename, "utf8"),
    async.asyncify(function (contents) {
        return db.model.create(contents);
    }),
    function (model, next) {
        // `model` 是 model 对象实例
        // 若出现错误，此函数会被跳过
    }
], callback);

// es2017 例子，当然如果 JS 环境支持 async 函数，就不需要 `asyncify` 化
var q = async.queue(async.asyncify(async function(file) {
    var intermediateStep = await processFile(file);
    return await somePromise(intermediateStep)
}));

q.push(files);

源码：

• asyncify.js, line 5

(static) constant() → {AsyncFunction}

import constant from 'async/constant';

参数：

返回：

类型

AsyncFunction

示例

async.waterfall([
    async.constant(42),
    function (value, next) {
        // value === 42
    },
    //...
], callback);

async.waterfall([
    async.constant(filename, "utf8"),
    fs.readFile,
    function (fileData, next) {
        //...
    }
    //...
], callback);

async.auto({
    hostname: async.constant("https://server.net/"),
    port: findFreePort,
    launchServer: ["hostname", "port", function (options, cb) {
        startServer(options, cb);
    }],
    //...
}, callback);

源码：

• constant.js, line 1

(static) dir(function)

import dir from 'async/dir';

参数：

示例

// in a module
var hello = function(name, callback) {
    setTimeout(function() {
        callback(null, {hello: name});
    }, 1000);
};

// in the node repl
node> async.dir(hello, 'world');
{hello: 'world'}

源码：

• dir.js, line 3

(static) ensureAsync(fn) → {AsyncFunction}

import ensureAsync from 'async/ensureAsync';

参数：

返回：

类型

AsyncFunction

示例

function sometimesAsync(arg, callback) {
    if (cache[arg]) {
        return callback(null, cache[arg]); // this would be synchronous!!
    } else {
        doSomeIO(arg, callback); // this IO would be asynchronous
    }
}

// this has a risk of stack overflows if many results are cached in a row
async.mapSeries(args, sometimesAsync, done);

// this will defer sometimesAsync's callback if necessary,
// preventing stack overflows
async.mapSeries(args, async.ensureAsync(sometimesAsync), done);

源码：

• ensureAsync.js, line 4

(static) log(function)

import log from 'async/log';

参数：

示例

// in a module
var hello = function(name, callback) {
    setTimeout(function() {
        callback(null, 'hello ' + name);
    }, 1000);
};

// in the node repl
node> async.log(hello, 'world');
'hello world'

源码：

• log.js, line 3

(static) memoize(fn, hasher) → {AsyncFunction}

import memoize from 'async/memoize';

参数：

返回：

类型

AsyncFunction

示例

var slow_fn = function(name, callback) {
    // do something
    callback(null, result);
};
var fn = async.memoize(slow_fn);

// fn can now be used as if it were slow_fn
fn('some name', function() {
    // callback
});

源码：

• memoize.js, line 5

(static) nextTick(callback)

import nextTick from 'async/nextTick';

参数：

示例

var call_order = [];
async.nextTick(function() {
    call_order.push('two');
    // call_order now equals ['one','two']
});
call_order.push('one');

async.setImmediate(function (a, b, c) {
    // a, b, and c equal 1, 2, and 3
}, 1, 2, 3);

源码：

• nextTick.js, line 5

参见：

• async.setImmediate

(static) reflect(fn) → {function}

import reflect from 'async/reflect';

参数：

返回：

类型

function

示例

async.parallel([
    async.reflect(function(callback) {
        // do some stuff ...
        callback(null, 'one');
    }),
    async.reflect(function(callback) {
        // do some more stuff but error ...
        callback('bad stuff happened');
    }),
    async.reflect(function(callback) {
        // do some more stuff ...
        callback(null, 'two');
    })
],
// optional callback
function(err, results) {
    // values
    // results[0].value = 'one'
    // results[1].error = 'bad stuff happened'
    // results[2].value = 'two'
});

源码：

• reflect.js, line 4

(static) reflectAll(tasks) → {Array}

import reflectAll from 'async/reflectAll';

参数：

返回：

类型

Array

示例

let tasks = [
    function(callback) {
        setTimeout(function() {
            callback(null, 'one');
        }, 200);
    },
    function(callback) {
        // do some more stuff but error ...
        callback(new Error('bad stuff happened'));
    },
    function(callback) {
        setTimeout(function() {
            callback(null, 'two');
        }, 100);
    }
];

async.parallel(async.reflectAll(tasks),
// optional callback
function(err, results) {
    // values
    // results[0].value = 'one'
    // results[1].error = Error('bad stuff happened')
    // results[2].value = 'two'
});

// an example using an object instead of an array
let tasks = {
    one: function(callback) {
        setTimeout(function() {
            callback(null, 'one');
        }, 200);
    },
    two: function(callback) {
        callback('two');
    },
    three: function(callback) {
        setTimeout(function() {
            callback(null, 'three');
        }, 100);
    }
};

async.parallel(async.reflectAll(tasks),
// optional callback
function(err, results) {
    // values
    // results.one.value = 'one'
    // results.two.error = 'two'
    // results.three.value = 'three'
});

源码：

• reflectAll.js, line 3

参见：

• async.reflect

(static) setImmediate(callback)

import setImmediate from 'async/setImmediate';

参数：

示例

var call_order = [];
async.nextTick(function() {
    call_order.push('two');
    // call_order now equals ['one','two']
});
call_order.push('one');

async.setImmediate(function (a, b, c) {
    // a, b, and c equal 1, 2, and 3
}, 1, 2, 3);

源码：

• setImmediate.js, line 3

参见：

• async.nextTick

(static) timeout(asyncFn, milliseconds, infoopt) → {AsyncFunction}

import timeout from 'async/timeout';

参数：

返回：

类型

AsyncFunction

示例

function myFunction(foo, callback) {
    doAsyncTask(foo, function(err, data) {
        // 处理错误
        if (err) return callback(err);

        // 处理事项 ...

        // return 处理后的数据
        return callback(null, data);
    });
}

var wrapped = async.timeout(myFunction, 1000);

// 以 `myFunction` 的同样方式调用 `wrapped`
wrapped({ bar: 'bar' }, function(err, data) {
    // 若 `myFunction` 执行耗时 < 1000 ms，`err`
    // 和 `data` 会以预期的值返回。

    // 不然 `err` 会是代码 'ETIMEDOUT' 的 Error
});

源码：

• timeout.js, line 4

(static) unmemoize(fn) → {AsyncFunction}

import unmemoize from 'async/unmemoize';

参数：

返回：

类型

AsyncFunction

源码：

• unmemoize.js, line 1

参见：

• async.memoize