Methods

(static) concat(coll, iteratee, callback(err)opt)

        import concat from 'async/concat';

Parameters:

Example

async.concat(['dir1','dir2','dir3'], fs.readdir, function(err, files) {
    // files 现在是给定的 3 个目录中存在的文件名的一个列表（list）
});

Source:

• concat.js, line 4

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

import concatLimit from 'async/concatLimit';

Parameters:

Source:

• concatLimit.js, line 8

See:

• async.concat

(static) concatSeries(coll, iteratee, callback(err)opt)

import concatSeries from 'async/concatSeries';

Parameters:

Source:

• concatSeries.js, line 4

See:

• async.concat

(static) detect(coll, iteratee, callbackopt)

import detect from 'async/detect';

Alias:

• find

Parameters:

Example

                        async.detect(['file1','file2','file3'], function(filePath, callback) {
    fs.access(filePath, function(err) {
        callback(null, !err)
    });
}, function(err, result) {
    // 结果现在等于列表中的存在第一个文件
});

                    

Source:

• detect.js, line 7

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

import detectLimit from 'async/detectLimit';

Alias:

• findLimit

Parameters:

Source:

• detectLimit.js, line 7

See:

• async.detect

(static) detectSeries(coll, iteratee, callbackopt)

import detectSeries from 'async/detectSeries';

Alias:

• findSeries

Parameters:

Source:

• detectSeries.js, line 4

See:

• async.detect

(static) each(coll, iteratee, callbackopt)

import each from 'async/each';

Alias:

• forEach

Parameters:

Example

// 假设 openFile 是一个文件名数组，saveFile 是一个用来保存文件的被修改内容的函数

async.each(openFiles, saveFile, function(err){
  // 如果任何保存产生了错误， err 就等于那个错误
});

// 假设 openFile 是一个文件名数组
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) {
    // 如果任何文件处理产生了错误， err 就等于那个错误
    if( err ) {
      // 其中一个迭代产生了一个错误。
      // 所有的处理都将停止。
      console.log('A file failed to process');
    } else {
      console.log('All files have been processed successfully');
    }
});

Source:

• each.js, line 5

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

import eachLimit from 'async/eachLimit';

Alias:

• forEachLimit

Parameters:

Source:

• eachLimit.js, line 5

See:

• async.each

(static) eachOf(coll, iteratee, callbackopt)

import eachOf from 'async/eachOf';

Alias:

• forEachOf

Parameters:

Example

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);
});

Source:

• eachOf.js, line 37

See:

• async.each

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

import eachOfLimit from 'async/eachOfLimit';

Alias:

• forEachOfLimit

Parameters:

Source:

• eachOfLimit.js, line 4

See:

• async.eachOf

(static) eachOfSeries(coll, iteratee, callbackopt)

import eachOfSeries from 'async/eachOfSeries';

Alias:

• forEachOfSeries

Parameters:

Source:

• eachOfSeries.js, line 4

See:

• async.eachOf

(static) eachSeries(coll, iteratee, callbackopt)

import eachSeries from 'async/eachSeries';

Alias:

• forEachSeries

Parameters:

Source:

• eachSeries.js, line 4

See:

• async.each

(static) every(coll, iteratee, callbackopt)

import every from 'async/every';

Alias:

• all

Parameters:

Example

async.every(['file1','file2','file3'], function(filePath, callback) {
    fs.access(filePath, function(err) {
        callback(null, !err)
    });
}, function(err, result) {
    // 如果 result 为真，那么每个文件都存在
});

Source:

• every.js, line 5

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

import everyLimit from 'async/everyLimit';

Alias:

• allLimit

Parameters:

Source:

• everyLimit.js, line 5

See:

• async.every

(static) everySeries(coll, iteratee, callbackopt)

import everySeries from 'async/everySeries';

Alias:

• allSeries

Parameters:

Source:

• everySeries.js, line 4

See:

• async.every

(static) filter(coll, iteratee, callbackopt)

import filter from 'async/filter';

Alias:

• select

Parameters:

Example

async.filter(['file1','file2','file3'], function(filePath, callback) {
    fs.access(filePath, function(err) {
        callback(null, !err)
    });
}, function(err, results) {
    // results 现在等于存在的文件的数组
});

Source:

• filter.js, line 4

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

import filterLimit from 'async/filterLimit';

Alias:

• selectLimit

Parameters:

Source:

• filterLimit.js, line 4

See:

• async.filter

(static) filterSeries(coll, iteratee, callbackopt)

import filterSeries from 'async/filterSeries';

Alias:

• selectSeries

Parameters:

Source:

• filterSeries.js, line 4

See:

• async.filter

(static) groupBy(coll, iteratee, callbackopt)

import groupBy from 'async/groupBy';

Parameters:

Example

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 是一个对象，它包含按照年龄分组的 usersIds。 
    // 例如 { 30: ['userId1', 'userId3'], 42: ['userId2']};
});

Source:

• groupBy.js, line 4

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

import groupByLimit from 'async/groupByLimit';

Parameters:

Source:

• groupByLimit.js, line 4

See:

• async.groupBy

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

import groupBySeries from 'async/groupBySeries';

Parameters:

Source:

• groupBySeries.js, line 4

See:

• async.groupBy

(static) map(coll, iteratee, callbackopt)

import map from 'async/map';

Parameters:

Example

async.map(['file1','file2','file3'], fs.stat, function(err, results) {
    // results 现在是每个文件的stats组成的数组。
});

Source:

• map.js, line 4

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

import mapLimit from 'async/mapLimit';

Parameters:

Source:

• mapLimit.js, line 4

See:

• async.map

(static) mapSeries(coll, iteratee, callbackopt)

import mapSeries from 'async/mapSeries';

Parameters:

Source:

• mapSeries.js, line 4

See:

• async.map

(static) mapValues(obj, iteratee, callbackopt)

import mapValues from 'async/mapValues';

Parameters:

Example

async.mapValues({
    f1: 'file1',
    f2: 'file2',
    f3: 'file3'
}, function (file, key, callback) {
  fs.stat(file, callback);
}, function(err, result) {
    // result 现在是每个文件的 stats的一个映射。例如：
    // {
    //     f1: [stats for file1],
    //     f2: [stats for file2],
    //     f3: [stats for file3]
    // }
});

Source:

• mapValues.js, line 5

(static) mapValuesLimit(obj, limit, iteratee, callbackopt)

import mapValuesLimit from 'async/mapValuesLimit';

Parameters:

Source:

• mapValuesLimit.js, line 7

See:

• async.mapValues

(static) mapValuesSeries(obj, iteratee, callbackopt)

import mapValuesSeries from 'async/mapValuesSeries';

Parameters:

Source:

• mapValuesSeries.js, line 4

See:

• async.mapValues

(static) reduce(coll, memo, iteratee, callbackopt)

import reduce from 'async/reduce';

Alias:

• foldl

Parameters:

Example

async.reduce([1,2,3], 0, function(memo, item, callback) {
    // 毫无意义的异步:
    process.nextTick(function() {
        callback(null, memo + item)
    });
}, function(err, result) {
    // result 现在等于 memo 的最后的值，为6
});

Source:

• reduce.js, line 6

(static) reduceRight(array, memo, iteratee, callbackopt)

import reduceRight from 'async/reduceRight';

Alias:

• foldr

Parameters:

Source:

• reduceRight.js, line 4

See:

• async.reduce

(static) reject(coll, iteratee, callbackopt)

import reject from 'async/reject';

Parameters:

Example

async.reject(['file1','file2','file3'], function(filePath, callback) {
    fs.access(filePath, function(err) {
        callback(null, !err)
    });
}, function(err, results) {
    // results 现在等于缺失文件的数组
    createFiles(results);
});

Source:

• reject.js, line 4

See:

• async.filter

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

import rejectLimit from 'async/rejectLimit';

Parameters:

Source:

• rejectLimit.js, line 4

See:

• async.reject

(static) rejectSeries(coll, iteratee, callbackopt)

import rejectSeries from 'async/rejectSeries';

Parameters:

Source:

• rejectSeries.js, line 4

See:

• async.reject

(static) some(coll, iteratee, callbackopt)

import some from 'async/some';

Alias:

• any

Parameters:

Example

async.some(['file1','file2','file3'], function(filePath, callback) {
    fs.access(filePath, function(err) {
        callback(null, !err)
    });
}, function(err, result) {
    // 如果 result 为 true，那么至少有一个文件是存在的
});

Source:

• some.js, line 5

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

import someLimit from 'async/someLimit';

Alias:

• anyLimit

Parameters:

Source:

• someLimit.js, line 5

See:

• async.some

(static) someSeries(coll, iteratee, callbackopt)

import someSeries from 'async/someSeries';

Alias:

• anySeries

Parameters:

Source:

• someSeries.js, line 4

See:

• async.some

(static) sortBy(coll, iteratee, callback)

import sortBy from 'async/sortBy';

Parameters:

Example

async.sortBy(['file1','file2','file3'], function(file, callback) {
    fs.stat(file, function(err, stats) {
        callback(err, stats.mtime);
    });
}, function(err, results) {
    // results 现在是原始的文件数组经过使用修改后的数据进行排序的结果
});

// 通过修改回调参数，可以影响排序顺序:

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

// 降序排序
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
});

Source:

• sortBy.js, line 7

(static) transform(coll, accumulatoropt, iteratee, callbackopt)

import transform from 'async/transform';

Parameters:

Examples

async.transform([1,2,3], function(acc, item, index, callback) {
    // 毫无意义的异步:
    process.nextTick(function() {
        acc.push(item * 2)
        callback(null)
    });
}, function(err, result) {
    // result 现在等于 [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 等于 {a: 2, b: 4, c: 6}
})

Source:

• transform.js, line 8

Methods

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

import applyEach from 'async/applyEach';

Parameters:

Returns:

Type

function

Example

async.applyEach([enableSearch, updateSchema], 'bucket', callback);

// 部分应用程序的例子:
async.each(
    buckets,
    async.applyEach([enableSearch, updateSchema]),
    callback
);

Source:

• applyEach.js, line 4

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

import applyEachSeries from 'async/applyEachSeries';

Parameters:

Returns:

Type

function

Source:

• applyEachSeries.js, line 4

See:

• async.applyEach

(static) auto(tasks, concurrencyopt, callbackopt)

import auto from 'async/auto';

Parameters:

Returns:

Example

async.auto({
    // 这个函数将只会被传入一个回调
    readData: async.apply(fs.readFile, 'data.txt', 'utf-8'),
    showData: ['readData', function(results, cb) {
        // results.readData 是文件的内容
        // ...
    }]
}, callback);

async.auto({
    get_data: function(callback) {
        console.log('in get_data');
        // 用来获取某些数据的异步代码
        callback(null, 'data', 'converted to array');
    },
    make_folder: function(callback) {
        console.log('in make_folder');
        // 用来创建一个存储文件的文件夹的异步代码
        // 这段代码是在获取数据的同时运行的
        callback(null, 'folder');
    },
    write_file: ['get_data', 'make_folder', function(results, callback) {
        console.log('in write_file', JSON.stringify(results));
        // 一旦有了一些数据，目录就存在了，
        // 将数据写入到目录中的文件
        callback(null, 'filename');
    }],
    email_link: ['write_file', function(results, callback) {
        console.log('in email_link', JSON.stringify(results));
        // 一旦文件被写好，让我们发送一个连接给它。
        // results.write_file 包含由 write_file 返回的文件名。
        callback(null, {'file':results.write_file, 'email':'user@example.com'});
    }]
}, function(err, results) {
    console.log('err = ', err);
    console.log('results = ', results);
});

Source:

• auto.js, line 13

(static) autoInject(tasks, callbackopt)

import autoInject from 'async/autoInject';

Parameters:

Example

//  `auto` 的例子可以被改写如下：
async.autoInject({
    get_data: function(callback) {
        // 获取某些数据的异步代码
        callback(null, 'data', 'converted to array');
    },
    make_folder: function(callback) {
        // 创建存储文件的文件夹的异步代码
        // 与获取数据同时运行
        callback(null, 'folder');
    },
    write_file: function(get_data, make_folder, callback) {
        // 一旦有了一些数据，目录就存在了，
        // 将数据写入到目录中的文件
        callback(null, 'filename');
    },
    email_link: function(write_file, callback) {
        // 一旦文件写入完成，让我们发送一个链接给它...
        // write_file 包含 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);
});

// 如果你正在使用 JS 压缩器，它会对参数名进行管理
// `autoInject` 将不能与普通函数一起工作，因为参数名将会被折叠成一个单一的字母标识符。
// 为了解决这个问题，您可以显式地指定任务函数在数组中需要的参数名称，类似于 Angular.js 依赖注入。

// 这仍然比普通 `auto` 有优势，因为任务所依赖的结果(results)仍然会被扩展到参数中。
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);
});

Source:

• autoInject.js, line 24

See:

• async.auto

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

import cargo from 'async/cargo';

Parameters:

Returns:

Type

CargoObject

Example

// 使用有效负载 2 创建一个 cargo 对象
var cargo = async.cargo(function(tasks, callback) {
    for (var i=0; i<tasks.length; i++) {
        console.log('hello ' + tasks[i].name);
    }
    callback();
}, 2);

// 添加一些项目
cargo.push({name: 'foo'}, function(err) {
    console.log('finished processing foo');
});
cargo.push({name: 'bar'}, function(err) {
    console.log('finished processing bar');
});
cargo.push({name: 'baz'}, function(err) {
    console.log('finished processing baz');
});

Source:

• cargo.js, line 33

See:

• async.queue

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

import compose from 'async/compose';

Parameters:

Returns:

Type

function

Example

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 现在等于 15
});

Source:

• compose.js, line 4

(static) doDuring(fn, test, callbackopt)

import doDuring from 'async/doDuring';

Parameters:

Source:

• doDuring.js, line 6

See:

• async.during

(static) doUntil(iteratee, test, callbackopt)

import doUntil from 'async/doUntil';

Parameters:

Source:

• doUntil.js, line 3

See:

• async.doWhilst

(static) doWhilst(iteratee, test, callbackopt)

import doWhilst from 'async/doWhilst';

Parameters:

Source:

• doWhilst.js, line 7

See:

• async.whilst

(static) during(test, fn, callbackopt)

import during from 'async/during';

Parameters:

Example

var count = 0;
async.during(
    function (callback) {
        return callback(null, count < 5);
    },
    function (callback) {
        count++;
        setTimeout(callback, 1000);
    },
    function (err) {
        //  5 秒被传入
    }
);

Source:

• during.js, line 5

See:

• async.whilst

(static) forever(fn, errbackopt)

import forever from 'async/forever';

Parameters:

Example

async.forever(
    function(next) {
        // next 适用于传递信息，需要一个回调（callback(err [, whatever])）；
        // 它将导致这个函数被再次调用。
    },
    function(err) {
        // 如果使用一个在 next 的第一个参数的值调用 next，那么它会出现在这里作为  'err&apos；并且执行会停止。
    }
);

Source:

• forever.js, line 7

(static) parallel(tasks, callbackopt)

import parallel from 'async/parallel';

Parameters:

Example

async.parallel([
    function(callback) {
        setTimeout(function() {
            callback(null, 'one');
        }, 200);
    },
    function(callback) {
        setTimeout(function() {
            callback(null, 'two');
        }, 100);
    }
],
// 可选回调
function(err, results) {
    // results 数组将等于 ['one','two']
    // 尽管第二个函数有一个更短些的超时。
});

// 一个使用对象（而不是数组）的示例
async.parallel({
    one: function(callback) {
        setTimeout(function() {
            callback(null, 1);
        }, 200);
    },
    two: function(callback) {
        setTimeout(function() {
            callback(null, 2);
        }, 100);
    }
}, function(err, results) {
    // results 现在等于: {one: 1, two: 2}
});

Source:

• parallel.js, line 4

(static) parallelLimit(tasks, limit, callbackopt)

import parallelLimit from 'async/parallelLimit';

Parameters:

Source:

• parallelLimit.js, line 4

See:

• async.parallel

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

import priorityQueue from 'async/priorityQueue';

Parameters:

Returns:

Type

QueueObject

Source:

• priorityQueue.js, line 8

See:

• async.queue

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

import queue from 'async/queue';

Parameters:

Returns:

Type

QueueObject

Example

// 使用 concurrency 2 创建一个队列对象。
var q = async.queue(function(task, callback) {
    console.log('hello ' + task.name);
    callback();
}, 2);

// 指定一个回调
q.drain = function() {
    console.log('all items have been processed');
};

// 添加一些项目到队列
q.push({name: 'foo'}, function(err) {
    console.log('finished processing foo');
});
q.push({name: 'bar'}, function (err) {
    console.log('finished processing bar');
});

// 添加一些项目到队列 (batch-wise 分批的)
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');
});

Source:

• queue.js, line 58

(static) race(tasks, callback)

import race from 'async/race';

Parameters:

Returns:

Example

async.race([
    function(callback) {
        setTimeout(function() {
            callback(null, 'one');
        }, 200);
    },
    function(callback) {
        setTimeout(function() {
            callback(null, 'two');
        }, 100);
    }
],
// 主回调
function(err, result) {
    // 借过等于 'two'，因为它完成得更早。
});

Source:

• race.js, line 6

(static) retry(optsopt, task, callbackopt)

import retry from 'async/retry';

Parameters:

Example

// The `retry` function can be used as a stand-alone control flow by passing
// 一个回调，如下所示:

// 尝试调用 apiMethod 3 次
async.retry(3, apiMethod, function(err, result) {
    // 使用result 做点什么事儿
});

//尝试调用 apiMethod 3 次, 每次尝试间等待 200 ms
async.retry({times: 3, interval: 200}, apiMethod, function(err, result) {
    // 使用result 做点什么事儿
});

// 使用指数后移调用 apiMethod 10次
// (即 intervals of 100, 200, 400, 800, 1600, ... 毫秒)
async.retry({
  times: 10,
  interval: function(retryCount) {
    return 50 * Math.pow(2, retryCount);
  }
}, apiMethod, function(err, result) {
    // 使用result 做点什么事儿
});

// 使用默认的 0 间隔，5次 尝试调用 apiMethod。
async.retry(apiMethod, function(err, result) {
    // 使用result 做点什么事儿
});

// 仅当错误条件满足时尝试调用 apiMethod，所有其他错误将中止重试控制流并返回到最终回调
async.retry({
  errorFilter: function(err) {
    return err.message === 'Temporary error'; // 仅当发生指定错误时继续重试。
  }
}, apiMethod, function(err, result) {
    // 使用result 做点什么事儿
});

// 要在其他控制流函数中重试不可靠的个别方法，请使用 `retryable` 包装器:
async.auto({
    users: api.getUsers.bind(api),
    payments: async.retryable(3, api.getPayments.bind(api))
}, function(err, results) {
    // 使用result 做点什么事儿
});

Source:

• retry.js, line 5

See:

• async.retryable

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

import retryable from 'async/retryable';

Parameters:

Returns:

Type

AsyncFunction

Example

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

Source:

• retryable.js, line 5

See:

• async.retry

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

import seq from 'async/seq';

Parameters:

Returns:

Type

function

Example

// 加载 lodash (或者 underscore), express3 和 dresende 的 orm2.
// 应用程序的一部分，这将获取已登录用户的cats。
// 这个示例使用 `seq` 函数来避免过度嵌套和错误。
// 处理混乱。
app.get('/cats', function(request, response) {
    var User = request.models.User;
    async.seq(
        _.bind(User.get, User),  // 'User.get' 有签名 (id, callback(err, data))
        function(user, fn) {
            user.getCats(fn);      // 'getCats' 有签名 (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 });
        }
    });
});

Source:

• seq.js, line 7

See:

• async.compose

(static) series(tasks, callbackopt)

import series from 'async/series';

Parameters:

Example

async.series([
    function(callback) {
        // 做一些事情 ...
        callback(null, 'one');
    },
    function(callback) {
        // 做更多事情...
        callback(null, 'two');
    }
],
// 可选的回调
function(err, results) {
    // results 现在等于 ['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 现在等于: {one: 1, two: 2}
});

Source:

• series.js, line 4

(static) times(n, iteratee, callback)

import times from 'async/times';

Parameters:

Example

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

// 生成 5 个用户
async.times(5, function(n, next) {
    createUser(n, function(err, user) {
        next(err, user);
    });
}, function(err, users) {
    // 我们现在应该有 5 个user
});

Source:

• times.js, line 4

See:

• async.map

(static) timesLimit(count, limit, iteratee, callback)

import timesLimit from 'async/timesLimit';

Parameters:

Source:

• timesLimit.js, line 5

See:

• async.times

(static) timesSeries(n, iteratee, callback)

import timesSeries from 'async/timesSeries';

Parameters:

Source:

• timesSeries.js, line 4

See:

• async.times

(static) tryEach(tasks, callbackopt)

import tryEach from 'async/tryEach';

Parameters:

Example

async.tryEach([
    function getDataFromFirstWebsite(callback) {
        // 尝试从第一个网站获取数据
        callback(err, data);
    },
    function getDataFromSecondWebsite(callback) {
        // 从第一个网站获取数据失败,
        // 尝试从备用网站获取数据
        callback(err, data);
    }
],
// 可选的回调
function(err, results) {
    // 现在使用获取的数据做点事情
});

Source:

• tryEach.js, line 6

(static) until(test, iteratee, callbackopt)

import until from 'async/until';

Parameters:

Source:

• until.js, line 3

See:

• async.whilst

(static) waterfall(tasks, callbackopt)

import waterfall from 'async/waterfall';

Parameters:

Returns:

Example

async.waterfall([
    function(callback) {
        callback(null, 'one', 'two');
    },
    function(arg1, arg2, callback) {
        // arg1 现在等于 'one' ， arg2 现在等于 'two'
        callback(null, 'three');
    },
    function(arg1, callback) {
        // arg1 现在等于 'three'
        callback(null, 'done');
    }
], function (err, result) {
    // result 现在等于 'done'
});

// 或者, 使用命名函数:
async.waterfall([
    myFirstFunction,
    mySecondFunction,
    myLastFunction,
], function (err, result) {
    // result 现在等于 'done'
});
function myFirstFunction(callback) {
    callback(null, 'one', 'two');
}
function mySecondFunction(arg1, arg2, callback) {
    // arg1 现在等于 'one' ， arg2 现在等于 'two'
    callback(null, 'three');
}
function myLastFunction(arg1, callback) {
    // arg1 现在等于 'three'
    callback(null, 'done');
}

Source:

• waterfall.js, line 9

(static) whilst(test, iteratee, callbackopt)

import whilst from 'async/whilst';

Parameters:

Returns:

Example

var count = 0;
async.whilst(
    function() { return count < 5; },
    function(callback) {
        count++;
        setTimeout(function() {
            callback(null, count);
        }, 1000);
    },
    function (err, n) {
        // 5 seconds 被传入, n = 5
    }
);

Source:

• whilst.js, line 7

Type Definitions

CargoObject

import cargo from 'async/cargo';

Type:

• Object

Properties:

Source:

• cargo.js, line 3

QueueObject

import queue from 'async/queue';

Type:

• Object

Properties:

Source:

• queue.js, line 4

Methods

(static) apply(fn) → {function}

import apply from 'async/apply';

Parameters:

Returns:

Type

function

Example

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


// 与不使用 apply 的相同过程
async.parallel([
    function(callback) {
        fs.writeFile('testfile1', 'test1', callback);
    },
    function(callback) {
        fs.writeFile('testfile2', 'test2', callback);
    }
]);

// 当调用 continuation 时，它可以被传入任意数量的附加参数：

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

Source:

• apply.js, line 3

(static) asyncify(func) → {AsyncFunction }

import asyncify from 'async/asyncify';

Alias:

• wrapSync

Parameters:

Returns:

Type

AsyncFunction

Example

// 传递一个常规的同步函数
async.waterfall([
    async.apply(fs.readFile, filename, "utf8"),
    async.asyncify(JSON.parse),
    function (data, next) {
        // 数据是解析文本的结果。
        // 如果解析发生错误，这个错误会被捕获。
    }
], 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);

Source:

• asyncify.js, line 5

(static) constant() → {AsyncFunction }

import constant from 'async/constant';

Parameters:

Returns:

Type

AsyncFunction

Example

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);

Source:

• constant.js, line 3

(static) dir(function)

import dir from 'async/dir';

Parameters:

Example

// 在一个模块中
var hello = function(name, callback) {
    setTimeout(function() {
        callback(null, {hello: name});
    }, 1000);
};

// 在 node 控制台中
node> async.dir(hello, 'world');
{hello: 'world'}

Source:

• dir.js, line 3

(static) ensureAsync(fn) → {AsyncFunction }

import ensureAsync from 'async/ensureAsync';

Parameters:

Returns:

Type

AsyncFunction

Example

function sometimesAsync(arg, callback) {
    if (cache[arg]) {
        return callback(null, cache[arg]); // 这将是同步的!!
    } else {
        doSomeIO(arg, callback); // 这个 IO 将是异步的。
    }
}

// 如果将许多结果缓存在行中，则会出现堆栈溢出的风险
async.mapSeries(args, sometimesAsync, done);

// 如果有必要，这将推迟 sometimesAsync 的回调，
// 防止堆栈溢出
async.mapSeries(args, async.ensureAsync(sometimesAsync), done);

Source:

• ensureAsync.js, line 5

(static) log(function)

import log from 'async/log';

Parameters:

Example

// 在一个模块中
var hello = function(name, callback) {
    setTimeout(function() {
        callback(null, 'hello ' + name);
    }, 1000);
};

// 在 node 控制台
node> async.log(hello, 'world');
'hello world'

Source:

• log.js, line 3

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

import memoize from 'async/memoize';

Parameters:

Returns:

Type

AsyncFunction

Example

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

// fn 现在可以被用作 slow_fn了
fn('some name', function() {
    // callback
});

Source:

• memoize.js, line 12

(static) nextTick(callback)

import nextTick from 'async/nextTick';

Parameters:

Example

var call_order = [];
async.nextTick(function() {
    call_order.push('two');
    // call_order 现在等于 ['one','two']
});
call_order.push('one');

async.setImmediate(function (a, b, c) {
    // a, b, 和 c 等于 1, 2, 和 3
}, 1, 2, 3);

Source:

• nextTick.js, line 5

See:

• async.setImmediate

(static) reflect(fn) → {function}

import reflect from 'async/reflect';

Parameters:

Returns:

Type

function

Example

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'
});

Source:

• reflect.js, line 5

(static) reflectAll(tasks) → {Array}

import reflectAll from 'async/reflectAll';

Parameters:

Returns:

Type

Array

Example

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'
});

// 使用对象的示例
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'
});

Source:

• reflectAll.js, line 6

See:

• async.reflect

(static) setImmediate(callback)

import setImmediate from 'async/setImmediate';

Parameters:

Example

var call_order = [];
async.nextTick(function() {
    call_order.push('two');
    // call_order 现在等于 ['one','two']
});
call_order.push('one');

async.setImmediate(function (a, b, c) {
    // a, b, 和 c 等于 1, 2, 和 3
}, 1, 2, 3);

Source:

• setImmediate.js, line 3

See:

• async.nextTick

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

import timeout from 'async/timeout';

Parameters:

Returns:

Type

AsyncFunction

Example

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

        // do some stuff ...

        // 返回处理后的 data
        return callback(null, data);
    });
}

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

// 就像调用 `myFunction` 那样调用 `wrapped` 
wrapped({ bar: 'bar' }, function(err, data) {
    // 如果 `myFunction` 花费 < 1000 ms的事件来执行，`err`
    // `err`  和 `data` 将包含他们执行后的值

    // 否则 `err` 将是一个 Error，错误代码为  'ETIMEDOUT'
});

Source:

• timeout.js, line 4

(static) unmemoize(fn) → {AsyncFunction }

import unmemoize from 'async/unmemoize';

Parameters:

Returns:

Type

AsyncFunction

Source:

• unmemoize.js, line 1

See:

• async.memoize