async

异步是一个实用程序模块,它提供直接,强大的功能来使用异步JavaScript. 尽管最初设计用于Node.js ,并且可以通过npm install --save async ,但它也可以直接在浏览器中使用.

Source:
See:

Collections

用于处理集合(例如数组和对象)的async函数的集合.

Source:

Methods

(static) concat(coll, iteratee, callbackopt)

import concat from 'async/concat';

适用iteratee每个项目在coll ,并将结果串联起来. 返回串联列表. 并行调用iteratee ,结果返回时将其串联在一起. 结果数组将按传递给iteratee函数的coll的原始顺序返回.

Alias:
  • flatMap
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

应用于coll每个项目的函数,该函数应使用数组作为结果. 调用了(项目,回调).

callback function <optional>

在所有iteratee函数完成或发生错误后调用的回调. 结果是一个数组,其中包含iteratee函数的串联结果. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Example
async.concat(['dir1','dir2','dir3'], fs.readdir, function(err, files) {
    // files is now a list of filenames that exist in the 3 directories
});
Source:

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

import concatLimit from 'async/concatLimit';

concat相同,但一次最多运行limit异步操作.

Alias:
  • flatMapLimit
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

limit number

一次的最大异步操作数.

iteratee AsyncFunction

应用于coll每个项目的函数,该函数应使用数组作为结果. 调用了(项目,回调).

callback function <optional>

在所有iteratee函数完成或发生错误后调用的回调. 结果是一个数组,其中包含iteratee函数的串联结果. 调用了(错误,结果).

Returns:

A Promise, if no callback is passed

Source:
See:

(static) concatSeries(coll, iteratee, callbackopt)

import concatSeries from 'async/concatSeries';

concat相同,但一次仅运行一个异步操作.

Alias:
  • flatMapSeries
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

应用于coll每个项目的函数. Iteratee应该以结果数组的形式完成. 调用了(项目,回调).

callback function <optional>

在所有iteratee函数完成或发生错误后调用的回调. 结果是一个数组,其中包含iteratee函数的串联结果. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Source:
See:

(static) detect(coll, iteratee, callbackopt)

import detect from 'async/detect';

返回coll中通过异步真值测试的第一个值. iteratee是并行应用的,这意味着第一个返回true iteratee将触发具有该结果的detect callback . 这意味着结果可能不是在原来的第一项coll是通过测试(在顺序方面). 如果原来的内秩序coll是很重要的,然后看detectSeries .

Alias:
  • find
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

适用于coll每个项目的真相测试. iteratee必须以布尔值作为结果来完成. 调用了(项目,回调).

callback function <optional>

一旦任何iteratee返回true ,或者在所有iteratee函数完成之后,将调用一个回调. 结果将是数组中通过真相测试(iteratee)的第一项,如果undefined通过则为undefined . 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Example
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
});
Source:

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

import detectLimit from 'async/detectLimit';

detect相同,但一次最多运行limit异步操作.

Alias:
  • findLimit
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

limit number

一次的最大异步操作数.

iteratee AsyncFunction

适用于coll每个项目的真相测试. iteratee必须以布尔值作为结果来完成. 调用了(项目,回调).

callback function <optional>

一旦任何iteratee返回true ,或者在所有iteratee函数完成之后,将调用一个回调. 结果将是数组中通过真相测试(iteratee)的第一项,如果undefined通过则为undefined . 调用了(错误,结果).

Returns:

如果未传递回调,则为Promise

Source:
See:

(static) detectSeries(coll, iteratee, callbackopt)

import detectSeries from 'async/detectSeries';

detect相同,但一次仅运行一个异步操作.

Alias:
  • findSeries
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

适用于coll每个项目的真相测试. iteratee必须以布尔值作为结果来完成. 调用了(项目,回调).

callback function <optional>

一旦任何iteratee返回true ,或者在所有iteratee函数完成之后,将调用一个回调. 结果将是数组中通过真相测试(iteratee)的第一项,如果undefined通过则为undefined . 调用了(错误,结果).

Returns:

如果未传递回调,则为Promise

Source:
See:

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

import each from 'async/each';

将函数iteratee并行应用于coll中的每个项目. 调用iteratee将使用列表中的一个项目,并在完成时进行回调. 如果iteratee将错误传递给其callback ,则立即使用错误调用主callback (针对each函数).

请注意,由于此函数并行地将iteratee应用于每个项目,因此不能保证iteratee功能将按顺序完成.

Alias:
  • forEach
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

一个异步函数,应用于coll每个项目. 调用了(项目,回调). 数组索引不会传递给iteratee. 如果需要索引,请使用eachOf .

callback function <optional>

当所有iteratee函数完成或发生错误时调用的回调. 用(err)调用.

Returns:

一个承诺,如果省略了回调

Type
Promise
Example
// assuming openFiles is an array of file names and saveFile is a function
// to save the modified contents of that file:

async.each(openFiles, saveFile, function(err){
  // if any of the saves produced an error, err would equal that error
});

// assuming openFiles is an array of file names
async.each(openFiles, function(file, callback) {

    // Perform operation on file here.
    console.log('Processing file ' + file);

    if( file.length > 32 ) {
      console.log('This file name is too long');
      callback('File name too long');
    } else {
      // Do work to process file here
      console.log('File processed');
      callback();
    }
}, function(err) {
    // if any of the file processing produced an error, err would equal that error
    if( err ) {
      // One of the iterations produced an error.
      // All processing will now stop.
      console.log('A file failed to process');
    } else {
      console.log('All files have been processed successfully');
    }
});
Source:

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

import eachLimit from 'async/eachLimit';

each相同,但一次最多运行limit异步操作.

Alias:
  • forEachLimit
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

limit number

一次的最大异步操作数.

iteratee AsyncFunction

一个异步函数,应用于coll每个项目. 数组索引不会传递给iteratee. 如果需要索引,请使用eachOfLimit . 调用了(项目,回调).

callback function <optional>

当所有iteratee函数完成或发生错误时调用的回调. 用(err)调用.

Returns:

一个承诺,如果省略了回调

Type
Promise
Source:
See:

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

import eachOf from 'async/eachOf';

each一样,除了它将键(或索引)作为第二个参数传递给iteratee.

Alias:
  • forEachOf
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

应用于coll每个项目的函数. key是项目的键,如果是数组,则为索引. 调用了(项,键,回调).

callback function <optional>

当所有iteratee函数完成或发生错误时调用的回调. 用(err)调用.

Returns:

一个承诺,如果省略了回调

Type
Promise
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 is now a map of JSON data
    doSomethingWith(configs);
});
Source:
See:

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

import eachOfLimit from 'async/eachOfLimit';

eachOf相同,但一次最多运行limit异步操作.

Alias:
  • forEachOfLimit
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

limit number

一次的最大异步操作数.

iteratee AsyncFunction

一个异步函数,应用于coll每个项目. key是项目的键,如果是数组,则为索引. 调用了(项,键,回调).

callback function <optional>

当所有iteratee函数完成或发生错误时调用的回调. 用(err)调用.

Returns:

一个承诺,如果省略了回调

Type
Promise
Source:
See:

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

import eachOfSeries from 'async/eachOfSeries';

eachOf相同,但一次仅运行一个异步操作.

Alias:
  • forEachOfSeries
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

一个异步函数,应用于coll每个项目. 调用了(项,键,回调).

callback function <optional>

当所有iteratee函数完成或发生错误时调用的回调. 用(err)调用.

Returns:

一个承诺,如果省略了回调

Type
Promise
Source:
See:

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

import eachSeries from 'async/eachSeries';

each相同,但一次仅运行一个异步操作.

注意,与each不同,此函数将iteratee应用于序列中的每个项目,因此iteratee函数将按顺序完成.

Alias:
  • forEachSeries
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

一个异步函数,应用于coll每个项目. 数组索引不会传递给iteratee. 如果需要索引,请使用eachOfSeries . 调用了(项目,回调).

callback function <optional>

当所有iteratee函数完成或发生错误时调用的回调. 用(err)调用.

Returns:

一个承诺,如果省略了回调

Type
Promise
Source:
See:

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

import every from 'async/every';

如果coll每个元素均满足异步测试,则返回true . 如果任何iteratee调用返回false ,则立即调用主callback .

Alias:
  • all
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

异步真理测试,以并行方式应用于集合中的每个项目. 迭代器必须以布尔结果值完成. 调用了(项目,回调).

callback function <optional>

在所有iteratee函数完成后调用的回调. 根据异步测试的值,结果将为truefalse . 调用了(错误,结果).

Returns:

一个承诺,如果没有提供回调

Type
Promise
Example
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
});
Source:

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

import everyLimit from 'async/everyLimit';

every相同,但一次最多运行limit异步操作.

Alias:
  • allLimit
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

limit number

一次的最大异步操作数.

iteratee AsyncFunction

异步真理测试,以并行方式应用于集合中的每个项目. 迭代器必须以布尔结果值完成. 调用了(项目,回调).

callback function <optional>

在所有iteratee函数完成后调用的回调. 根据异步测试的值,结果将为truefalse . 调用了(错误,结果).

Returns:

一个承诺,如果没有提供回调

Type
Promise
Source:
See:

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

import everySeries from 'async/everySeries';

every相同,但every仅运行一个异步操作.

Alias:
  • allSeries
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

异步真理性测试,适用于系列中的每个项目. 迭代器必须以布尔结果值完成. 调用了(项目,回调).

callback function <optional>

在所有iteratee函数完成后调用的回调. 根据异步测试的值,结果将为truefalse . 调用了(错误,结果).

Returns:

一个承诺,如果没有提供回调

Type
Promise
Source:
See:

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

import filter from 'async/filter';

返回通过异步真理测试的coll中所有值的新数组. 该操作是并行执行的,但是结果数组的顺序与原始顺序相同.

Alias:
  • select
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee function

A truth test to apply to each item in coll. The iteratee is passed a callback(err, truthValue), which must be called with a boolean argument once it has completed. Invoked with (item, callback).

callback function <optional>

在所有iteratee函数完成后调用的回调. 调用了(错误,结果).

Returns:

一个承诺,如果没有提供回调

Type
Promise
Example
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
});
Source:

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

import filterLimit from 'async/filterLimit';

filter相同,但一次最多运行limit异步操作.

Alias:
  • selectLimit
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

limit number

一次的最大异步操作数.

iteratee function

适用于coll每个项目的真相测试. iteratee传递了一个callback(err, truthValue) ,一旦完成,必须使用布尔参数调用它. 调用了(项目,回调).

callback function <optional>

在所有iteratee函数完成后调用的回调. 调用了(错误,结果).

Returns:

一个承诺,如果没有提供回调

Type
Promise
Source:
See:

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

import filterSeries from 'async/filterSeries';

filter相同,但一次仅运行一个异步操作.

Alias:
  • selectSeries
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee function

适用于coll每个项目的真相测试. iteratee传递了一个callback(err, truthValue) ,一旦完成,必须使用布尔参数调用它. 调用了(项目,回调).

callback function <optional>

在所有iteratee函数完成后调用的回调. 调用了(错误,结果)

Returns:

一个承诺,如果没有提供回调

Type
Promise
Source:
See:

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

import groupBy from 'async/groupBy';

返回一个新对象,其中每个值都对应于coll一组项,这些项返回了对应的键. 也就是说,对象的键对应于传递给iteratee回调的值.

注意:由于此功能并行地将iteratee应用于每个项目,因此不能保证iteratee功能将按顺序完成. 但是, result每个键的值将与原始coll顺序相同. 对于对象,值将大致按原始对象键的顺序排列(但在JavaScript引擎中可能有所不同).

Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

一个异步函数,应用于coll每个项目. 迭代器应带有将值归类的key . 调用了(值,回调).

callback function <optional>

当所有iteratee函数完成或发生错误时调用的回调. 结果是一个Object其属性是返回相应键的值的数组.

Returns:

一个承诺,如果没有传递回调

Type
Promise
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 is object containing the userIds grouped by age
    // e.g. { 30: ['userId1', 'userId3'], 42: ['userId2']};
});
Source:

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

import groupByLimit from 'async/groupByLimit';

groupBy相同,但一次最多运行limit异步操作.

Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

limit number

一次的最大异步操作数.

iteratee AsyncFunction

一个异步函数,应用于coll每个项目. 迭代器应带有将值归类的key . 调用了(值,回调).

callback function <optional>

当所有iteratee函数完成或发生错误时调用的回调. 结果是一个Object其属性是返回相应键的值的数组.

Returns:

一个承诺,如果没有传递回调

Type
Promise
Source:
See:

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

import groupBySeries from 'async/groupBySeries';

groupBy相同,但一次仅运行一个异步操作.

Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

An async function to apply to each item in coll. The iteratee should complete with a key to group the value under. Invoked with (value, callback).

callback function <optional>

当所有iteratee函数完成或发生错误时调用的回调. 结果是一个Object其属性是返回相应键的值的数组.

Returns:

一个承诺,如果没有传递回调

Type
Promise
Source:
See:

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

import map from 'async/map';

通过iteratee函数映射coll每个值,从而产生新的值集合. 调用iteratee会使用来自coll的项目以及完成处理时的回调. 这些回调中的每一个都带有2个参数: errorcoll转换后的项目. 如果iteratee将错误传递给其回调,则立即使用错误调用主callback (用于map函数).

请注意,由于此函数并行地将iteratee应用于每个项目,因此不能保证iteratee函数将按顺序完成. 但是,结果数组的顺序与原始coll顺序相同.

如果map传递了一个Object,则结果将是一个Array. 结果大致按原始Objects的键顺序排列(但在JavaScript引擎之间可能有所不同).

Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

一个异步函数,应用于coll每个项目. 迭代器应完成转换后的项. 调用了(项目,回调).

callback function <optional>

当所有iteratee函数完成或发生错误时调用的回调. 结果是coll转换后的项的数组. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

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

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

import mapLimit from 'async/mapLimit';

map相同,但一次最多运行limit异步操作.

Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

limit number

一次的最大异步操作数.

iteratee AsyncFunction

一个异步函数,应用于coll每个项目. 迭代器应完成转换后的项. 调用了(项目,回调).

callback function <optional>

当所有iteratee函数完成或发生错误时调用的回调. 结果是coll转换后的项的数组. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Type
Promise
Source:
See:

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

import mapSeries from 'async/mapSeries';

map相同,但一次仅运行一个异步操作.

Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

一个异步函数,应用于coll每个项目. 迭代器应完成转换后的项. 调用了(项目,回调).

callback function <optional>

当所有iteratee函数完成或发生错误时调用的回调. 结果是coll转换后的项的数组. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Type
Promise
Source:
See:

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

import mapValues from 'async/mapValues';

map的亲戚,设计用于对象.

通过iteratee函数映射obj每个值来产生一个新的Object. iteratee被称为obj每个valuekey ,并在处理完成时被称为回调. 这些回调中的每个回调都有两个参数: errorobj转换后的项目. 如果iteratee将错误传递给其回调,则立即使用错误调用主callback (用于mapValues函数).

注意,不能保证结果中键的顺序. 密钥大致按其完成的顺序排列(但这是特定于引擎的)

Parameters:
Name Type Description
obj Object

一个要迭代的集合.

iteratee AsyncFunction

应用于coll每个值和键的函数. 迭代器应将转换后的值作为结果完成. 用(值,键,回调)调用.

callback function <optional>

当所有iteratee函数完成或发生错误时调用的回调. result是一个新对象,由obj的每个键组成,每个转换后的值在右侧. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Type
Promise
Example
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]
    // }
});
Source:

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

import mapValuesLimit from 'async/mapValuesLimit';

mapValues相同,但一次最多运行limit异步操作.

Parameters:
Name Type Description
obj Object

一个要迭代的集合.

limit number

一次的最大异步操作数.

iteratee AsyncFunction

应用于coll每个值和键的函数. 迭代器应将转换后的值作为结果完成. 用(值,键,回调)调用.

callback function <optional>

当所有iteratee函数完成或发生错误时调用的回调. result是一个新对象,由obj的每个键组成,每个转换后的值在右侧. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Type
Promise
Source:
See:

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

import mapValuesSeries from 'async/mapValuesSeries';

mapValues相同,但一次仅运行一个异步操作.

Parameters:
Name Type Description
obj Object

一个要迭代的集合.

iteratee AsyncFunction

应用于coll每个值和键的函数. 迭代器应将转换后的值作为结果完成. 用(值,键,回调)调用.

callback function <optional>

当所有iteratee函数完成或发生错误时调用的回调. result是一个新对象,由obj的每个键组成,每个转换后的值在右侧. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Type
Promise
Source:
See:

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

import reduce from 'async/reduce';

使用异步iterateecoll减少为单个值,以返回每个后续步骤. memo是减少的初始状态. 此功能只能串联使用.

出于性能原因,将对此函数的调用拆分为并行映射,然后对结果使用常规Array.prototype.reduce可能很有意义. 此功能适用于减少步骤中的每个步骤都需要异步的情况; 如果您可以在减少数据之前获取数据,那么这样做可能是一个好主意.

Alias:
  • foldl
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

memo *

还原的初始状态.

iteratee AsyncFunction

应用于数组中每个项目的函数以产生约简的下一步. iteratee应完成缩减的下一个状态. 如果iteratee完成并有错误,则还原将停止,并立即以错误调用主callback . 调用了(备注,项目,回调).

callback function <optional>

在所有iteratee函数完成后调用的回调. 结果是减少的值. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Type
Promise
Example
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
});
Source:

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

import reduceRight from 'async/reduceRight';

reduce相同,仅以相反的顺序对array进行操作.

Alias:
  • foldr
Parameters:
Name Type Description
array Array

A collection to iterate over.

memo *

还原的初始状态.

iteratee AsyncFunction

应用于数组中每个项目的函数以产生约简的下一步. iteratee应完成缩减的下一个状态. 如果iteratee完成并有错误,则还原将停止,并立即以错误调用主callback . 调用了(备注,项目,回调).

callback function <optional>

在所有iteratee函数完成后调用的回调. 结果是减少的值. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Type
Promise
Source:
See:

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

import reject from 'async/reject';

filter相反. 删除通过async真值测试的值.

Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee function

异步真理测试,适用于coll每个项目. 本应以布尔值作为其完成result . 调用了(项目,回调).

callback function <optional>

A callback which is called after all the iteratee functions have finished. Invoked with (err, results).

Returns:

一个承诺,如果没有传递回调

Type
Promise
Example
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);
});
Source:
See:

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

import rejectLimit from 'async/rejectLimit';

reject相同,但一次最多运行limit异步操作.

Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

limit number

一次的最大异步操作数.

iteratee function

异步真理测试,适用于coll每个项目. 本应以布尔值作为其完成result . 调用了(项目,回调).

callback function <optional>

在所有iteratee函数完成后调用的回调. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Type
Promise
Source:
See:

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

import rejectSeries from 'async/rejectSeries';

reject相同,但一次仅运行一个异步操作.

Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee function

异步真理测试,适用于coll每个项目. 本应以布尔值作为其完成result . 调用了(项目,回调).

callback function <optional>

在所有iteratee函数完成后调用的回调. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Type
Promise
Source:
See:

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

import some from 'async/some';

如果coll中的至少一个元素满足异步测试,则返回true . 如果任何iteratee调用返回true ,则立即调用主callback .

Alias:
  • any
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

异步真理测试,以并行方式应用于集合中的每个项目. iteratee应该以布尔result值完成. 调用了(项目,回调).

callback function <optional>

一旦任何iteratee返回true ,或者在所有iteratee函数完成之后,将调用一个回调. 根据异步测试的值,结果将为truefalse . 调用了(错误,结果).

Returns:

一个承诺,如果没有提供回调

Type
Promise
Example
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
});
Source:

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

import someLimit from 'async/someLimit';

The same as some but runs a maximum of limit async operations at a time.

Alias:
  • anyLimit
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

limit number

一次的最大异步操作数.

iteratee AsyncFunction

异步真理测试,以并行方式应用于集合中的每个项目. iteratee应该以布尔result值完成. 调用了(项目,回调).

callback function <optional>

一旦任何iteratee返回true ,或者在所有iteratee函数完成之后,将调用一个回调. 根据异步测试的值,结果将为truefalse . 调用了(错误,结果).

Returns:

一个承诺,如果没有提供回调

Type
Promise
Source:
See:

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

import someSeries from 'async/someSeries';

some相同,但一次仅运行一个异步操作.

Alias:
  • anySeries
Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

异步真理测试,适用于系列中的每个项目. iteratee应该以布尔result值完成. 调用了(项目,回调).

callback function <optional>

一旦任何iteratee返回true ,或者在所有iteratee函数完成之后,将调用一个回调. 根据异步测试的值,结果将为truefalse . 调用了(错误,结果).

Returns:

一个承诺,如果没有提供回调

Type
Promise
Source:
See:

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

import sortBy from 'async/sortBy';

根据通过异步iteratee运行每个coll值的结果对列表进行排序.

Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

iteratee AsyncFunction

一个异步函数,应用于coll每个项目. Iteratee应该以一个值作为result作为排序标准来完成. 调用了(项目,回调).

callback function

在所有iteratee函数完成或发生错误后调用的回调. 结果是从原来的项目coll由返回的值进行排序iteratee电话. 调用了(错误,结果).

Returns:

一个承诺,如果没有通过回调

Type
Promise
Example
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
});
Source:

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

import transform from 'async/transform';

reduce的亲戚. 获取一个对象或数组,并并行地遍历每个元素,每个步骤都有可能使accumulator值变异. 累加器的类型默认为传入的集合的类型.

Parameters:
Name Type Description
coll Array | Iterable | AsyncIterable | Object

一个要迭代的集合.

accumulator * <optional>

转换的初始状态. 如果省略,它将默认为空的Object或Array,具体取决于coll的类型

iteratee AsyncFunction

应用于集合中每个项目的函数,有可能会修改累加器. 调用了(累加器,项目,键,回调).

callback function <optional>

在所有iteratee函数完成后调用的回调. 结果就是转换后的累加器. 调用了(错误,结果).

Returns:

一个承诺,如果没有提供回调

Type
Promise
Examples
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}
})
Source:

Control Flow

async函数的集合,用于控制通过脚本的流.

Source:

Methods

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

import applyEach from 'async/applyEach';

将提供的参数应用于数组中的每个函数,在所有函数完成后调用callback . 如果仅提供第一个参数fns ,则它将返回一个函数,该函数使您可以像传入单个函数一样传递参数. 如果提供了更多参数,则需要callback ,而args仍是可选的. 每个应用的异步函数的结果都作为数组传递到最终回调.

Parameters:
Name Type Description
fns Array | Iterable | AsyncIterable | Object

带有相同参数的所有调用的AsyncFunction的集合

args * <optional>

要传递给函数的任意数量的单独参数.

callback function <optional>

最后一个参数应该是回调,在所有函数完成处理后调用.

Returns:
  • 返回一个除可选回调外不带参数的函数,这是将args应用于每个函数的结果.
Type
AsyncFunction
Example
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
);
Source:

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

import applyEachSeries from 'async/applyEachSeries';

applyEach相同,但一次仅运行一个异步操作.

Parameters:
Name Type Description
fns Array | Iterable | AsyncIterable | Object

带有相同参数的所有调用的AsyncFunction的集合

args * <optional>

要传递给函数的任意数量的单独参数.

callback function <optional>

最后一个参数应该是回调,在所有函数完成处理后调用.

Returns:
  • 一个函数,当被调用时,是将args应用于函数列表的结果. 除了回调外,它不需要参数.
Type
AsyncFunction
Source:
See:

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

import auto from 'async/auto';

根据tasks的需求,确定在tasks运行AsyncFunction的最佳顺序. 每个功能可以有选择地依赖于其他先完成的功能,并且每个功能只要满足其要求就可以运行.

如果任何AsyncFunction将错误传递给其回调,则auto序列将停止. 进一步的任务将不会执行(因此,取决于它的任何其他功能将不会运行),并且会立即调用main callback并显示错误.

AsyncFunction还会接收一个对象,该对象包含到目前为止具有第一个参数的函数的结果(如果它们具有依赖项). 如果任务函数没有依赖关系,则只会传递一个回调.

Parameters:
Name Type Default Description
tasks Object

一个东西. 它的每个属性都是一个函数或一组需求,而AsyncFunction本身就是数组中的最后一项. 属性的对象键用作该属性定义的任务的名称,即可以在指定其他任务的要求时使用. 该函数接收一个或两个参数:

  • 一个results对象,其中包含先前执行的函数的结果,仅在任务具有任何依赖项时才传递,
  • 一个callback(err, result)函数,必须在完成后调用,并传递一个error (可以为null )和函数执行的结果.
concurrency number <optional> Infinity

一个可选的integer用于确定可以并行运行的最大任务数. 默认情况下,越多越好.

callback function <optional>

一个可选的回调,当所有任务都完成时调用. 如果任何tasks将错误传递给其回调,则它将接收err参数. 结果总是返回; 但是,如果发生错误,将不再执行其他tasks ,并且结果对象将仅包含部分结果. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Type
Promise
Example
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);
});
Source:

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

import autoInject from 'async/autoInject';

async.auto函数的依赖项注入版本. 在通常的回调参数之后,将相关任务指定为该函数的参数,并且参数名称与其依赖的任务名称相匹配. 这可以提供更易读的任务图,从而更易于维护.

如果指定了最终回调,则将类似地注入任务结果,并在初始错误参数之后将其指定为命名参数.

autoInject函数纯粹是语法糖,其语义在其他方面等效于async.auto .

Parameters:
Name Type Description
tasks Object

一个对象,每个对象的属性是形式为'func([dependencies ...],callback)的AsyncFunction . 属性的对象键用作该属性定义的任务的名称,即可以在指定其他任务的要求时使用.

  • callback参数是一个callback(err, result) ,在完成时必须调用该方法,并传递一个error (可以为null )和函数执行的结果. 其余参数为该任务所依赖的其他任务命名,这些任务的结果就是这些参数的参数.
callback function <optional>

一个可选的回调,当所有任务都完成时调用. 如果任何tasks将错误传递到其回调,则它将接收err参数,以及具有任何完成的任务结果的results对象,类似于auto .

Returns:

一个承诺,如果没有传递回调

Type
Promise
Example
//  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);
});
Source:
See:

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

import cargo from 'async/cargo';

创建具有指定有效负载的cargo对象. 添加到货物中的任务将被一起处理(直到payload限制). 如果worker进程正在进行中,则将任务排队直到可用. worker完成某些任务后,将调用这些任务的每个回调. 查看这些 动画 ,了解cargoqueue工作方式.

queue仅将一个任务传递给一组工人中的一个,而货物则将一系列任务传递给单个工人,并在工人完成作业时重复执行.

Parameters:
Name Type Default Description
worker AsyncFunction

异步函数,用于处理排队的任务数组. 用(tasks, callback)调用.

payload number <optional> Infinity

一个可选的integer用于确定每轮应处理多少个任务; 如果省略,则默认为无限制.

Returns:

A cargo object to manage the tasks. Callbacks can attached as certain properties to listen for specific events during the lifecycle of the cargo and inner queue.

Type
QueueObject
Example
// 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');
Source:
See:

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

import cargoQueue from 'async/cargoQueue';

用指定的有效负载创建一个cargoQueue对象. 添加到cargoQueue中的任务将在concurrency并行工作器中一起处理(达到payload限制). 如果所有workers都在进行中,则将任务排队,直到一个可用. worker完成某些任务后,将调用这些任务的每个回调. 查看这些 动画 ,了解cargoqueue工作方式.

queue仅将一个任务传递给一组工人中的一个,而cargo将一组任务传递给单个工人,而cargoQueue将一组任务传递给多个并行工人.

Parameters:
Name Type Default Description
worker AsyncFunction

异步函数,用于处理排队的任务数组. 用(tasks, callback)调用.

concurrency number <optional> 1

一个integer用于确定应并行运行多少个worker函数. 如果省略,则并发默认为1 . 如果并发为0 ,则会引发错误.

payload number <optional> Infinity

一个可选的integer用于确定每轮应处理多少个任务; 如果省略,则默认为无限制.

Returns:

cargoQueue对象,用于管理任务. 可以将回调附加为某些属性,以在cargoQueue和内部队列的生命周期中侦听特定事件.

Type
QueueObject
Example
// 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');
});
Source:
See:

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

import compose from 'async/compose';

创建一个函数,该函数由传递的异步函数组成. 每个函数消耗后面的函数的返回值. 组合函数f()g()h()会产生f(g(h())) ,只有此版本使用回调来获取返回值.

如果组合函数的最后一个参数不是函数,则在调用它时将返回一个promise.

每个功能都是通过组合功能的this绑定执行的.

Parameters:
Name Type Description
functions AsyncFunction

异步函数组成

Returns:

由组成的异步functions组成的异步functions

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 now equals 15
});
Source:

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

import doUntil from 'async/doUntil';

类似于" doWhilst" ,只是test是反向的. 请注意,参数顺序不同于until .

Parameters:
Name Type Description
iteratee AsyncFunction

每次test失败时都会调用一个异步函数. 用(回调)调用.

test AsyncFunction

在每次iteratee执行后执行的异步真相测试. 用(... args,callback)调用,其中...argsiteratee上一个回调中的非错误args

callback function <optional>

在测试函数通过且iteratee重复执行已停止之后调用的回调. callback将传递一个错误,所有参数都传递给最终iteratee的回调. 调用了(错误,[结果]);

Returns:

一个承诺,如果没有传递回调

Type
Promise
Source:
See:

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

import doWhilst from 'async/doWhilst';

后检查版本的whilst . 为了反映操作顺序的差异,请切换参数testiteratee .

doWhilstwhilstdo whilewhile在普通的JavaScript.

Parameters:
Name Type Description
iteratee AsyncFunction

每次test通过时都会调用的功能. 用(回调)调用.

test AsyncFunction

在每次iteratee执行后执行的异步真相测试. 用(... args,callback)调用,其中...argsiteratee上一个回调中的非错误args.

callback function <optional>

在测试功能失败并且iteratee重复执行停止后调用的回调. callback将传递一个错误,所有参数都传递给最终iteratee的回调. 调用了(错误,[结果]);

Returns:

一个承诺,如果没有传递回调

Type
Promise
Source:
See:

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

import forever from 'async/forever';

用回调参数调用异步函数fn ,该参数允许它无限期地再次连续调用自己. 如果将错误传递给回调,则会使用该错误调用errback ,然后执行停止,否则将永远不会调用它.

Parameters:
Name Type Description
fn AsyncFunction

an async function to call repeatedly. Invoked with (next).

errback function <optional>

fn向其回调传递错误时,将调用此函数,并停止执行. 用(err)调用.

Returns:

一个承诺,如果发生错误并且未通过错误返回,则拒绝

Type
Promise
Example
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.
    }
);
Source:

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

import parallel from 'async/parallel';

并行运行功能的tasks集合,而无需等待上一个功能完成. 如果任何一个函数将错误传递给其回调,则立即使用错误的值调用主callback . tasks完成后,结果将作为数组传递到最终callback .

注意: parallel是关于parallel启动I / O任务,而不是并行执行代码. 如果您的任务不使用任何计时器或执行任何I / O,则它们实际上将串行执行. 每个任务的任何同步设置部分都会一个接一个地发生. JavaScript保持单线程.

提示:当任务失败时,使用reflect来继续执行其他任务.

也可以使用对象而不是数组. 每个属性将作为函数运行,结果将作为对象而不是数组传递到最终callback . 这可能是处理async.parallel结果的一种更具可读性的方法.

Parameters:
Name Type Description
tasks Array | Iterable | AsyncIterable | Object

要运行的异步函数的集合. 每个异步功能可以完成任意数量的可选result值.

callback function <optional>

所有功能成功完成后运行的可选回调. 该函数获取一个结果数组(或对象),该数组包含传递给任务回调的所有结果参数. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Type
Promise
Example
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}
});
Source:

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

import parallelLimit from 'async/parallelLimit';

parallel操作相同,但一次最多运行limit异步操作.

Parameters:
Name Type Description
tasks Array | Iterable | AsyncIterable | Object

要运行的异步函数的集合. 每个异步功能可以完成任意数量的可选result值.

limit number

一次的最大异步操作数.

callback function <optional>

所有功能成功完成后运行的可选回调. 该函数获取一个结果数组(或对象),该数组包含传递给任务回调的所有结果参数. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Type
Promise
Source:
See:

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

import priorityQueue from 'async/priorityQueue';

async.queue相同,仅为任务分配优先级,并以优先级升序完成.

Parameters:
Name Type Description
worker AsyncFunction

用于处理排队任务的异步功能. 如果要处理单个任务的错误, q.push()回调传递给q.push() . 用(任务,回调)调用.

concurrency number

一个integer用于确定应并行运行多少个worker函数. 如果省略,则并发默认为1 . 如果并发为0 ,则会引发错误.

Returns:

一个PriorityQueue对象来管理任务. queuepriorityQueue对象之间有两个区别:

  • push(task, priority, [callback]) - priority应该是一个数字. 如果给定一系列tasks ,则将为所有任务分配相同的优先级.
  • 取消unshift方法.
Type
QueueObject
Source:
See:

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

import queue from 'async/queue';

创建具有指定concurrencyqueue对象. 并行处理添加到queue中的任务(直到concurrency限制). 如果所有worker进程都在进行中,则将任务排队,直到一个任务可用为止. worker完成task ,将调用该task的回调.

Parameters:
Name Type Default Description
worker AsyncFunction

用于处理排队任务的异步功能. 如果要处理单个任务的错误, q.push()回调传递给q.push() . 用(任务,回调)调用.

concurrency number <optional> 1

一个integer用于确定应并行运行多少个worker函数. 如果省略,则并发默认为1 . 如果并发为0 ,则会引发错误.

Returns:

用于管理任务的队列对象. 可以将回调附加为某些属性,以在队列的生命周期中侦听特定事件.

Type
QueueObject
Example
// create a queue object with concurrency 2
var q = async.queue(function(task, callback) {
    console.log('hello ' + task.name);
    callback();
}, 2);

// assign a callback
q.drain(function() {
    console.log('all items have been processed');
});
// or await the end
await q.drain()

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

// add some items to the queue
q.push({name: 'foo'}, function(err) {
    console.log('finished processing foo');
});
// callback is optional
q.push({name: 'bar'});

// add some items to the queue (batch-wise)
q.push([{name: 'baz'},{name: 'bay'},{name: 'bax'}], function(err) {
    console.log('finished processing item');
});

// add some items to the front of the queue
q.unshift({name: 'bar'}, function (err) {
    console.log('finished processing bar');
});
Source:

(static) race(tasks, callback)

import race from 'async/race';

并行运行tasks的功能数组,而无需等到上一个功能完成. 一旦任何tasks完成或将错误传递给其回调,便立即调用主callback . 它等效于Promise.race() .

Parameters:
Name Type Description
tasks Array

包含要运行的异步函数的数组. 每个函数都可以带有可选的result值.

callback function

任何功能完成后要运行的回调. 此函数从完成的第一个函数中获取错误或结果. 调用了(错误,结果).

Returns:

undefined

Example
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
});
Source:

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

import retry from 'async/retry';

尝试从task获得成功响应的times不超过返回错误之前的次数. 如果任务成功,则将向callback传递成功任务的结果. 如果所有尝试均失败,则将向回调传递错误和最终尝试的结果(如果有).

Parameters:
Name Type Default Description
opts Object | number <optional> {次:5,间隔:0} | 5

可以是具有timesinterval的对象,也可以是数字.

  • times -放弃前要进行的尝试次数. 默认值为5 .
  • interval重试之间的等待时间,以毫秒为单位. 默认值为0 . 也可以根据重试次数指定间隔(请参见示例).
  • errorFilter在错误结果上调用的可选同步函数. 如果返回true则重试尝试将继续;否则,将重试. 如果函数返回false则重试流将中止,并显示当前尝试的错误,结果将返回到最终回调. 用(err)调用.
  • 如果opts是一个数字,则该数字指定重试的次数,默认间隔为0 .
task AsyncFunction

重试异步功能. 用(回调)调用.

callback function <optional>

可选回调,在任务成功执行或最终失败尝试后调用. 它接收完成task的最后尝试的errresult参数. 调用了(错误,结果).

Returns:

没有提供回调的承诺

Type
Promise
Example
// 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
});
Source:
See:

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

import retryable from 'async/retryable';

retry近亲. 此方法包装任务并使它可重试,而不是立即重试调用它.

Parameters:
Name Type Default Description
opts Object | number <optional> {次:5,间隔:0} | 5

可选选项,与from retry完全相同,除了opts.aritytask函数的task.length ,默认为task.length

task AsyncFunction

要包装的异步函数. 该函数将传递给传递给返回的包装器的所有参数. 用(... args,回调)调用.

Returns:

包装的函数在被调用时将根据opts指定的参数重试错误. 此函数将接受与task相同的参数.

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

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

import seq from 'async/seq';

撰写功能的版本更自然易读. 每个函数消耗前一个函数的返回值. 它等同于compose,其中的参数取反.

每个功能都是通过组合功能的this绑定执行的.

Parameters:
Name Type Description
functions AsyncFunction

异步函数组成

Returns:

按顺序组成functions

Type
function
Example
// 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 });
        }
    });
});
Source:
See:

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

import series from 'async/series';

依次运行tasks集合中的功能,每一个都在上一个功能完成后运行. 如果系列中的任何函数将错误传递给其回调,则不会再运行任何函数,并且会立即使用错误的值调用callback . 否则,当tasks完成时, callback收到结果数组.

也可以使用对象而不是数组. 每个属性都将作为函数运行,并且结果将作为对象而不是数组传递到最终callback . 这是处理async.series结果的一种更易读的方法.

请注意 ,尽管许多实现保留了对象属性的顺序,但ECMAScript语言规范明确指出:

未指定枚举属性的机制和顺序.

因此,如果您依赖于一系列功能的执行顺序,并且希望该功能在所有平台上都能正常工作,请考虑使用数组.

Parameters:
Name Type Description
tasks Array | Iterable | AsyncIterable | Object

包含要串行运行的异步函数的集合. 每个函数可以完成任意数量的可选result值.

callback function <optional>

所有功能完成后运行的可选回调. 该函数获取一个结果数组(或对象),该数组包含传递给task回调的所有结果参数. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Type
Promise
Example
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}
});
Source:

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

import times from 'async/times';

调用iteratee函数n次,并以与map相同的方式累积结果.

Parameters:
Name Type Description
n number

运行该功能的次数.

iteratee AsyncFunction

异步函数调用n次. 用迭代索引和回调调用:(n,下一个).

callback function

see map.

Returns:

一个诺言,如果没有提供回调

Type
Promise
Example
// 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
});
Source:
See:

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

import timesLimit from 'async/timesLimit';

时间相同,但一次最多运行limit异步操作.

Parameters:
Name Type Description
count number

运行该功能的次数.

limit number

一次的最大异步操作数.

iteratee AsyncFunction

异步函数调用n次. 用迭代索引和回调调用:(n,下一个).

callback function

see async.map.

Returns:

一个诺言,如果没有提供回调

Type
Promise
Source:
See:

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

import timesSeries from 'async/timesSeries';

时间相同,但一次仅运行一个异步操作.

Parameters:
Name Type Description
n number

运行该功能的次数.

iteratee AsyncFunction

异步函数调用n次. 用迭代索引和回调调用:(n,下一个).

callback function

see map.

Returns:

一个诺言,如果没有提供回调

Type
Promise
Source:
See:

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

import tryEach from 'async/tryEach';

它按顺序运行每个任务,但是只要有任何功能成功就停止. 如果其中一项任务成功,则将向callback传递成功任务的结果. 如果所有任务均失败,则将向回调传递错误和最终尝试的结果(如果有).

Parameters:
Name Type Description
tasks Array | Iterable | AsyncIterable | Object

一个包含要运行的函数的集合,每个函数都传递一个callback(err, result) ,该callback(err, result)必须在完成时调用,并带有错误err (可以为null )和可选的result值.

callback function <optional>

可选回调,当一项任务成功或全部失败时调用. 它接收完成task的最后尝试的errresult参数. 调用了(错误,结果).

Returns:

一个承诺,如果没有传递回调

Type
Promise
Example
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.
});
Source:

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

import until from 'async/until';

重复调用iteratee直到test返回true为止. 停止或发生错误时调用callback . callback将传递一个错误,所有参数都传递给最终iteratee的回调.

的逆同时 .

Parameters:
Name Type Description
test AsyncFunction

在每次iteratee执行之前执行的异步真相测试. 用(回调)调用.

iteratee AsyncFunction

每次test失败时都会调用一个异步函数. 用(回调)调用.

callback function <optional>

在测试函数通过且iteratee重复执行已停止之后调用的回调. callback将传递一个错误,所有参数都传递给最终iteratee的回调. 调用了(错误,[结果]);

Returns:

一个承诺,如果没有传递回调

Type
Promise
Example
const results = []
let finished = false
async.until(function test(page, 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
})
Source:
See:

(static) waterfall(tasks, callbackopt)

import waterfall from 'async/waterfall';

依次运行tasks的函数数组,每个函数将其结果传递给数组中的下一个. 但是,如果任何tasks将错误传递给它们自己的回调,则不会执行下一个函数,并且主callback将立即被错误调用.

Parameters:
Name Type Description
tasks Array

一组要运行的异步函数 . 每个函数应具有任意数量的result值. result值将作为参数依次传递到下一个任务.

callback function <optional>

所有功能完成后运行的可选回调. 这将传递上一个任务的回调结果. 用(错误,[结果])调用.

Returns:

undefined

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

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

import whilst from 'async/whilst';

反复调用iteratee ,而test返回true . 停止或发生错误时调用callback .

Parameters:
Name Type Description
test AsyncFunction

在每次iteratee执行之前执行的异步真相测试. 用()调用.

iteratee AsyncFunction

每次test通过时都会调用一个异步函数. 用(回调)调用.

callback function <optional>

在测试功能失败并且iteratee重复执行停止后调用的回调. callback将传递一个错误,所有参数都传递给最终iteratee的回调. 调用了(错误,[结果]);

Returns:

一个承诺,如果没有传递回调

Type
Promise
Example
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
    }
);
Source:

Type Definitions

QueueObject

import queue from 'async/queue';

工作者函数要完成的任务队列.

Type:
  • Iterable
Properties:
Name Type Description
length function

一个函数,返回等待处理的项目数. 用queue.length()调用.

started boolean

一个布尔值,指示队列是否推送和处理了任何项目.

running function

该函数返回当前正在处理的项目数. 用queue.running()调用.

workersList function

返回当前正在处理的项目数组的函数. 用queue.workersList()调用.

idle function

如果有正在等待或正在处理的项目,则返回false;否则返回true. 用queue.idle()调用.

concurrency number

一个整数,用于确定应并行运行多少个worker函数. 创建queue以即时更改并发之后,可以更改此属性.

payload number

一个整数,指定一次将多少个项目传递给worker函数. 仅在这是货物对象时适用

push AsyncFunction

将新任务添加到queue . worker完成任务处理后,调用callback . 可以提交一个tasks数组,而不是单个任务. 列表中的每个任务都使用相应的回调. 使用queue.push(task, [callback])

unshift AsyncFunction

将新任务添加到queue的最前面. 使用queue.unshift(task, [callback]) .

pushAsync AsyncFunction

q.push相同,除了会返回一个承诺,如果发生错误,承诺将被拒绝.

unshirtAsync AsyncFunction

q.unshift相同,除了会返回一个承诺,如果发生错误,该承诺将拒绝.

remove function

从队列中删除与测试功能匹配的项目. 如果这是一个priorityQueue对象,那么将向测试函数传递一个具有data属性和priority属性的对象. 用queue.remove(testFn)调用,其中testFn function ({data, priority}) {}形式的function ({data, priority}) {}并返回布尔值.

saturated function

a function that sets a callback that is called when the number of running workers hits the concurrency limit, and further tasks will be queued. If the callback is omitted, q.saturated() returns a promise for the next occurrence.

unsaturated function

一个函数,该函数设置一个回调,当正在运行的工作程序的数量小于concurrencybuffer限制时,将调用此回调,并且其他任务将不会排队. 如果省略了回调,则q.unsaturated()返回下一次出现的承诺.

buffer number

最小阈值缓冲区,以便说queueunsaturated .

empty function

一个设置回调的函数,当queue的最后一项被提供给worker时调用该回调. 如果省略了回调,则q.empty()返回下一次出现的承诺.

drain function

一个设置回调的函数,当queue的最后一个项目从worker返回时调用该回调. 如果省略了回调,则q.drain()返回下一次出现的承诺.

error function

设置在任务出错时调用的回调的函数. 具有签名function(error, task) . 如果省略了回调,则error()返回一个对下一个错误拒绝的承诺.

paused boolean

一个布尔值,用于确定队列是否处于暂停状态.

pause function

一个函数,该函数暂停任务的处理,直到调用resume()为止. 用queue.pause()调用.

resume function

该功能可在队列暂停时恢复对排队任务的处理. 用queue.resume()调用.

kill function

该函数删除drain回调并从队列中清空剩余的任务,以使其变为空闲状态. 调用此函数后,不应再将更多任务推入队列. 用queue.kill()调用.

Source:
Example
const q = async.queue(worker, 2)
q.push(item1)
q.push(item2)
q.push(item3)
// queues are iterable, spread into an array to inspect
const items = [...q] // [item1, item2, item3]
// or use for of
for (let item of q) {
    console.log(item)
}

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

Utils

async实用程序功能的集合.

Source:

Methods

(static) apply(fn) → {function}

import apply from 'async/apply';

创建具有某些自变量的延续函数.

与其他控制流功能结合使用时,可作为简写形式使用. 传递给返回函数的所有参数都将添加到最初传递给apply的参数中.

Parameters:
Name Type Description
fn function

您要最终将所有参数应用到的函数. 用(参数...)调用.

arguments... *

调用延续时可自动应用的任意数量的参数.

Returns:

部分应用的功能

Type
function
Example
// 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
Source:

(static) asyncify(func) → {AsyncFunction}

import asyncify from 'async/asyncify';

使用同步函数并使它异步,将其返回值传递给回调. 这对于将同步功能插入到瀑布式,系列或其他异步功能中很有用. 传递给生成的函数的所有参数都将传递给包装的函数(最终的回调参数除外). 引发的错误将传递给回调.

如果传递给asyncify的函数返回Promise,则将使用promises的已解决/已拒绝状态来调用回调,而不是简单地返回同步返回值.

这也意味着您可以async化ES2017 async功能.

Alias:
  • wrapSync
Parameters:
Name Type Description
func function

同步函数或Promise返回函数,可转换为AsyncFunction .

Returns:

func的异步包装器. 用(args..., callback)调用.

Type
AsyncFunction
Example
// passing a regular synchronous function
async.waterfall([
    async.apply(fs.readFile, filename, "utf8"),
    async.asyncify(JSON.parse),
    function (data, next) {
        // data is the result of parsing the text.
        // If there was a parsing error, it would have been caught.
    }
], callback);

// passing a function returning a promise
async.waterfall([
    async.apply(fs.readFile, filename, "utf8"),
    async.asyncify(function (contents) {
        return db.model.create(contents);
    }),
    function (model, next) {
        // `model` is the instantiated model object.
        // If there was an error, this function would be skipped.
    }
], callback);

// es2017 example, though `asyncify` is not needed if your JS environment
// supports async functions out of the box
var q = async.queue(async.asyncify(async function(file) {
    var intermediateStep = await processFile(file);
    return await somePromise(intermediateStep)
}));

q.push(files);
Source:

(static) constant() → {AsyncFunction}

import constant from 'async/constant';

返回一个函数,该函数在调用时将使用提供的值进行回调. 用作waterfall的第一个功能,或将值插入到auto .

Parameters:
Name Type Description
arguments... *

Any number of arguments to automatically invoke callback with.

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:

(static) dir(function)

import dir from 'async/dir';

使用console.dirasync功能的结果记录到console以显示结果对象的属性. 仅在Node.js或支持console.dirconsole.error浏览器(例如FF和Chrome)中工作. 如果从异步函数返回了多个参数,则对每个参数依次调用console.dir .

Parameters:
Name Type Description
function AsyncFunction

您要最终将所有参数应用到的函数.

arguments... *

适用于该函数的任意数量的参数.

Example
// 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'}
Source:

(static) ensureAsync(fn) → {AsyncFunction}

import ensureAsync from 'async/ensureAsync';

包装一个异步函数,并确保它在事件循环的稍后时刻调用其回调. 如果该函数已经在下一个刻度上调用其回调,则不会添加任何额外的延迟. 这对于防止堆栈溢出( RangeError: Maximum call stack size exceeded )以及通常保持Zalgo有用 . ES2017 async函数按原样返回-它们不受Zalgo的破坏性影响,因为它们始终在以后的时间滴答中解决.

Parameters:
Name Type Description
fn AsyncFunction

一个异步函数,该函数期望将节点样式的回调作为其最后一个参数.

Returns:

返回具有与传入函数完全相同的调用签名的包装函数.

Type
AsyncFunction
Example
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);
Source:

(static) log(function)

import log from 'async/log';

async功能的结果记录到console . 仅在Node.js或支持console.logconsole.error浏览器(例如FF和Chrome)中工作. 如果从异步函数返回了多个参数, console.log顺序在每个参数上调用console.log .

Parameters:
Name Type Description
function AsyncFunction

您要最终将所有参数应用到的函数.

arguments... *

适用于该函数的任意数量的参数.

Example
// 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'
Source:

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

import memoize from 'async/memoize';

缓存异步函数的结果. 创建用于存储函数结果的哈希时,哈希中将省略回调,并且可以使用可选的哈希函数.

Note: if the async function errs, the result will not be cached and subsequent calls will call the wrapped function.

如果未指定哈希函数,则将第一个参数用作哈希键,如果它是字符串或转换为不同字符串的数据类型,则可以合理地使用. 请注意,对象和数组将无法正常运行. 其他论点很重要的情况也不会. 在这种情况下,请指定您自己的哈希函数.

结果缓存显示为memoize返回的函数的memo属性.

Parameters:
Name Type Description
fn AsyncFunction

用于代理和缓存结果的异步函数.

hasher function

可选函数,用于生成用于存储结果的自定义哈希. 除了回调外,它还应用了所有参数,并且必须是同步的.

Returns:

fn的记忆版本

Type
AsyncFunction
Example
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
});
Source:

(static) nextTick(callback)

import nextTick from 'async/nextTick';

在事件循环周围的更高循环上调用callback . 在Node.js中,这仅调用process.nextTick . 在浏览器中,它将使用setImmediate如果可用),否则将使用setTimeout(callback, 0) ,这意味着其他更高优先级的事件可能在callback执行之前.

在内部用于浏览器兼容目的.

Parameters:
Name Type Description
callback function

围绕事件循环在以后的循环上调用的函数. 调用了(args ...).

args... *

任何数量的其他参数将在下一个刻度时传递给回调.

Example
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);
Source:
See:

(static) reflect(fn) → {function}

import reflect from 'async/reflect';

将异步函数包装在总是用结果对象完成的另一个函数中,即使它出错了.

结果对象具有属性errorvalue .

Parameters:
Name Type Description
fn AsyncFunction

您要包装的异步函数

Returns:
  • 始终将null作为错误传递给其回调的函数. 第二个参数回调将是一个object与任何一个errorvalue属性.
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:

(static) reflectAll(tasks) → {Array}

import reflectAll from 'async/reflectAll';

一个辅助函数,该函数使用reflect包装一个数组或一个函数对象.

Parameters:
Name Type Description
tasks Array | Object | Iterable

要包装在async.reflect异步函数的集合.

Returns:

返回异步函数数组,每个函数都包装在async.reflect

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

// 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'
});
Source:
See:

(static) setImmediate(callback)

import setImmediate from 'async/setImmediate';

在事件循环周围的更高循环上调用callback . 在Node.js中,这仅调用setImmediate . 在浏览器中,它将使用setImmediate如果可用),否则将使用setTimeout(callback, 0) ,这意味着其他更高优先级的事件可能在callback执行之前.

在内部用于浏览器兼容目的.

Parameters:
Name Type Description
callback function

围绕事件循环在以后的循环上调用的函数. 调用了(args ...).

args... *

任何数量的其他参数将在下一个刻度时传递给回调.

Example
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);
Source:
See:

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

import timeout from 'async/timeout';

设置异步函数的时间限制. 如果函数未在指定的毫秒内调用其回调,则将在超时错误的情况下调用该函数. 错误对象的代码属性将为'ETIMEDOUT' .

Parameters:
Name Type Description
asyncFn AsyncFunction

异步功能来限制时间.

milliseconds number

指定的时间限制.

info * <optional>

您想要附加到超时错误的任何变量( stringobject等)以获取更多信息.

Returns:

返回可与任何控制流函数一起使用的包装函数. 使用与asyncFunc相同的参数调用此函数.

Type
AsyncFunction
Example
function myFunction(foo, callback) {
    doAsyncTask(foo, function(err, data) {
        // handle errors
        if (err) return callback(err);

        // do some stuff ...

        // return processed data
        return callback(null, data);
    });
}

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

// call `wrapped` as you would `myFunction`
wrapped({ bar: 'bar' }, function(err, data) {
    // if `myFunction` takes < 1000 ms to execute, `err`
    // and `data` will have their expected values

    // else `err` will be an Error with the code 'ETIMEDOUT'
});
Source:

(static) unmemoize(fn) → {AsyncFunction}

import unmemoize from 'async/unmemoize';

撤消一个memoize的 d功能,恢复到原来的,unmemoized形式. 方便进行测试.

Parameters:
Name Type Description
fn AsyncFunction

记忆功能

Returns:

调用原始未记忆函数的函数

Type
AsyncFunction
Source:
See:

by  ICOPY.SITE