Methods

(static) concat(coll, iteratee, callbackopt)

import concat from 'async/concat';

Alias:

• flatMap

Parameters:

Returns:

Example

// dir1 is a directory that contains file1.txt, file2.txt
// dir2 is a directory that contains file3.txt, file4.txt
// dir3 is a directory that contains file5.txt
// dir4 does not exist

let directoryList = ['dir1','dir2','dir3'];
let withMissingDirectoryList = ['dir1','dir2','dir3', 'dir4'];

// Using callbacks
async.concat(directoryList, fs.readdir, function(err, results) {
   if (err) {
       console.log(err);
   } else {
       console.log(results);
       // [ 'file1.txt', 'file2.txt', 'file3.txt', 'file4.txt', file5.txt ]
   }
});

// Error Handling
async.concat(withMissingDirectoryList, fs.readdir, function(err, results) {
   if (err) {
       console.log(err);
       // [ Error: ENOENT: no such file or directory ]
       // since dir4 does not exist
   } else {
       console.log(results);
   }
});

// Using Promises
async.concat(directoryList, fs.readdir)
.then(results => {
    console.log(results);
    // [ 'file1.txt', 'file2.txt', 'file3.txt', 'file4.txt', file5.txt ]
}).catch(err => {
     console.log(err);
});

// Error Handling
async.concat(withMissingDirectoryList, fs.readdir)
.then(results => {
    console.log(results);
}).catch(err => {
    console.log(err);
    // [ Error: ENOENT: no such file or directory ]
    // since dir4 does not exist
});

// Using async/await
async () => {
    try {
        let results = await async.concat(directoryList, fs.readdir);
        console.log(results);
        // [ 'file1.txt', 'file2.txt', 'file3.txt', 'file4.txt', file5.txt ]
    } catch (err) {
        console.log(err);
    }
}

// Error Handling
async () => {
    try {
        let results = await async.concat(withMissingDirectoryList, fs.readdir);
        console.log(results);
    } catch (err) {
        console.log(err);
        // [ Error: ENOENT: no such file or directory ]
        // since dir4 does not exist
    }
}

Source:

• concat.js, line 4

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

import concatLimit from 'async/concatLimit';

Alias:

• flatMapLimit

Parameters:

Returns:

Source:

• concatLimit.js, line 5

See:

• async.concat

(static) concatSeries(coll, iteratee, callbackopt)

import concatSeries from 'async/concatSeries';

Alias:

• flatMapSeries

Parameters:

Returns:

Source:

• concatSeries.js, line 4

See:

• async.concat

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

import detect from 'async/detect';

Alias:

• find

Parameters:

Returns:

Type

Promise

Example

// dir1 is a directory that contains file1.txt, file2.txt
// dir2 is a directory that contains file3.txt, file4.txt
// dir3 is a directory that contains file5.txt

// asynchronous function that checks if a file exists
function fileExists(file, callback) {
   fs.access(file, fs.constants.F_OK, (err) => {
       callback(null, !err);
   });
}

async.detect(['file3.txt','file2.txt','dir1/file1.txt'], fileExists,
   function(err, result) {
       console.log(result);
       // dir1/file1.txt
       // result now equals the first file in the list that exists
   }
);

// Using Promises
async.detect(['file3.txt','file2.txt','dir1/file1.txt'], fileExists)
.then(result => {
    console.log(result);
    // dir1/file1.txt
    // result now equals the first file in the list that exists
}).catch(err => {
    console.log(err);
});

// Using async/await
async () => {
    try {
        let result = await async.detect(['file3.txt','file2.txt','dir1/file1.txt'], fileExists);
        console.log(result);
        // dir1/file1.txt
        // result now equals the file in the list that exists
    }
    catch (err) {
        console.log(err);
    }
}

Source:

• detect.js, line 5

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

import detectLimit from 'async/detectLimit';

Alias:

• findLimit

Parameters:

Returns:

Type

Promise

Source:

• detectLimit.js, line 5

See:

• async.detect

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

import detectSeries from 'async/detectSeries';

Alias:

• findSeries

Parameters:

Returns:

Type

Promise

Source:

• detectSeries.js, line 5

See:

• async.detect

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

import each from 'async/each';

Alias:

• forEach

Parameters:

Returns:

Type

Promise

Example

// dir1 is a directory that contains file1.txt, file2.txt
// dir2 is a directory that contains file3.txt, file4.txt
// dir3 is a directory that contains file5.txt
// dir4 does not exist

const fileList = [ 'dir1/file2.txt', 'dir2/file3.txt', 'dir/file5.txt'];
const withMissingFileList = ['dir1/file1.txt', 'dir4/file2.txt'];

// asynchronous function that deletes a file
const deleteFile = function(file, callback) {
    fs.unlink(file, callback);
};

// Using callbacks
async.each(fileList, deleteFile, function(err) {
    if( err ) {
        console.log(err);
    } else {
        console.log('All files have been deleted successfully');
    }
});

// Error Handling
async.each(withMissingFileList, deleteFile, function(err){
    console.log(err);
    // [ Error: ENOENT: no such file or directory ]
    // since dir4/file2.txt does not exist
    // dir1/file1.txt could have been deleted
});

// Using Promises
async.each(fileList, deleteFile)
.then( () => {
    console.log('All files have been deleted successfully');
}).catch( err => {
    console.log(err);
});

// Error Handling
async.each(fileList, deleteFile)
.then( () => {
    console.log('All files have been deleted successfully');
}).catch( err => {
    console.log(err);
    // [ Error: ENOENT: no such file or directory ]
    // since dir4/file2.txt does not exist
    // dir1/file1.txt could have been deleted
});

// Using async/await
async () => {
    try {
        await async.each(files, deleteFile);
    }
    catch (err) {
        console.log(err);
    }
}

// Error Handling
async () => {
    try {
        await async.each(withMissingFileList, deleteFile);
    }
    catch (err) {
        console.log(err);
        // [ Error: ENOENT: no such file or directory ]
        // since dir4/file2.txt does not exist
        // dir1/file1.txt could have been deleted
    }
}

Source:

• each.js, line 6

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

import eachLimit from 'async/eachLimit';

Alias:

• forEachLimit

Parameters:

Returns:

Type

Promise

Source:

• eachLimit.js, line 6

See:

• async.each

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

import eachOf from 'async/eachOf';

Alias:

• forEachOf

Parameters:

Returns:

Type

Promise

Example

// dev.json is a file containing a valid json object config for dev environment
// dev.json is a file containing a valid json object config for test environment
// prod.json is a file containing a valid json object config for prod environment
// invalid.json is a file with a malformed json object

let configs = {}; //global variable
let validConfigFileMap = {dev: 'dev.json', test: 'test.json', prod: 'prod.json'};
let invalidConfigFileMap = {dev: 'dev.json', test: 'test.json', invalid: 'invalid.json'};

// asynchronous function that reads a json file and parses the contents as json object
function parseFile(file, key, callback) {
    fs.readFile(file, "utf8", function(err, data) {
        if (err) return calback(err);
        try {
            configs[key] = JSON.parse(data);
        } catch (e) {
            return callback(e);
        }
        callback();
    });
}

// Using callbacks
async.forEachOf(validConfigFileMap, parseFile, function (err) {
    if (err) {
        console.error(err);
    } else {
        console.log(configs);
        // configs is now a map of JSON data, e.g.
        // { dev: //parsed dev.json, test: //parsed test.json, prod: //parsed prod.json}
    }
});

//Error handing
async.forEachOf(invalidConfigFileMap, parseFile, function (err) {
    if (err) {
        console.error(err);
        // JSON parse error exception
    } else {
        console.log(configs);
    }
});

// Using Promises
async.forEachOf(validConfigFileMap, parseFile)
.then( () => {
    console.log(configs);
    // configs is now a map of JSON data, e.g.
    // { dev: //parsed dev.json, test: //parsed test.json, prod: //parsed prod.json}
}).catch( err => {
    console.error(err);
});

//Error handing
async.forEachOf(invalidConfigFileMap, parseFile)
.then( () => {
    console.log(configs);
}).catch( err => {
    console.error(err);
    // JSON parse error exception
});

// Using async/await
async () => {
    try {
        let result = await async.forEachOf(validConfigFileMap, parseFile);
        console.log(configs);
        // configs is now a map of JSON data, e.g.
        // { dev: //parsed dev.json, test: //parsed test.json, prod: //parsed prod.json}
    }
    catch (err) {
        console.log(err);
    }
}

//Error handing
async () => {
    try {
        let result = await async.forEachOf(invalidConfigFileMap, parseFile);
        console.log(configs);
    }
    catch (err) {
        console.log(err);
        // JSON parse error exception
    }
}

Source:

• eachOf.js, line 42

See:

• async.each

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

import eachOfLimit from 'async/eachOfLimit';

Alias:

• forEachOfLimit

Parameters:

Returns:

Type

Promise

Source:

• eachOfLimit.js, line 5

See:

• async.eachOf

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

import eachOfSeries from 'async/eachOfSeries';

Alias:

• forEachOfSeries

Parameters:

Returns:

Type

Promise

Source:

• eachOfSeries.js, line 4

See:

• async.eachOf

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

import eachSeries from 'async/eachSeries';

Alias:

• forEachSeries

Parameters:

Returns:

Type

Promise

Source:

• eachSeries.js, line 4

See:

• async.each

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

import every from 'async/every';

Alias:

• all

Parameters:

Returns:

Type

Promise

Example

// dir1 is a directory that contains file1.txt, file2.txt
// dir2 is a directory that contains file3.txt, file4.txt
// dir3 is a directory that contains file5.txt
// dir4 does not exist

const fileList = ['dir1/file1.txt','dir2/file3.txt','dir3/file5.txt'];
const withMissingFileList = ['file1.txt','file2.txt','file4.txt'];

// asynchronous function that checks if a file exists
function fileExists(file, callback) {
   fs.access(file, fs.constants.F_OK, (err) => {
       callback(null, !err);
   });
}

// Using callbacks
async.every(fileList, fileExists, function(err, result) {
    console.log(result);
    // true
    // result is true since every file exists
});

async.every(withMissingFileList, fileExists, function(err, result) {
    console.log(result);
    // false
    // result is false since NOT every file exists
});

// Using Promises
async.every(fileList, fileExists)
.then( result => {
    console.log(result);
    // true
    // result is true since every file exists
}).catch( err => {
    console.log(err);
});

async.every(withMissingFileList, fileExists)
.then( result => {
    console.log(result);
    // false
    // result is false since NOT every file exists
}).catch( err => {
    console.log(err);
});

// Using async/await
async () => {
    try {
        let result = await async.every(fileList, fileExists);
        console.log(result);
        // true
        // result is true since every file exists
    }
    catch (err) {
        console.log(err);
    }
}

async () => {
    try {
        let result = await async.every(withMissingFileList, fileExists);
        console.log(result);
        // false
        // result is false since NOT every file exists
    }
    catch (err) {
        console.log(err);
    }
}

Source:

• every.js, line 5

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

import everyLimit from 'async/everyLimit';

Alias:

• allLimit

Parameters:

Returns:

Type

Promise

Source:

• everyLimit.js, line 5

See:

• async.every

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

import everySeries from 'async/everySeries';

Alias:

• allSeries

Parameters:

Returns:

Type

Promise

Source:

• everySeries.js, line 5

See:

• async.every

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

import filter from 'async/filter';

Alias:

• select

Parameters:

Returns:

Type

Promise

Example

// dir1 is a directory that contains file1.txt, file2.txt
// dir2 is a directory that contains file3.txt, file4.txt
// dir3 is a directory that contains file5.txt

const files = ['dir1/file1.txt','dir2/file3.txt','dir3/file6.txt'];

// asynchronous function that checks if a file exists
function fileExists(file, callback) {
   fs.access(file, fs.constants.F_OK, (err) => {
       callback(null, !err);
   });
}

// Using callbacks
async.filter(files, fileExists, function(err, results) {
   if(err) {
       console.log(err);
   } else {
       console.log(results);
       // [ 'dir1/file1.txt', 'dir2/file3.txt' ]
       // results is now an array of the existing files
   }
});

// Using Promises
async.filter(files, fileExists)
.then(results => {
    console.log(results);
    // [ 'dir1/file1.txt', 'dir2/file3.txt' ]
    // results is now an array of the existing files
}).catch(err => {
    console.log(err);
});

// Using async/await
async () => {
    try {
        let results = await async.filter(files, fileExists);
        console.log(results);
        // [ 'dir1/file1.txt', 'dir2/file3.txt' ]
        // results is now an array of the existing files
    }
    catch (err) {
        console.log(err);
    }
}

Source:

• filter.js, line 5

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

import filterLimit from 'async/filterLimit';

Alias:

• selectLimit

Parameters:

Returns:

Type

Promise

Source:

• filterLimit.js, line 5

See:

• async.filter

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

import filterSeries from 'async/filterSeries';

Alias:

• selectSeries

Parameters:

Returns:

Type

Promise

Source:

• filterSeries.js, line 5

See:

• async.filter

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

import groupBy from 'async/groupBy';

Parameters:

Returns:

Type

Promise

Example

// dir1 is a directory that contains file1.txt, file2.txt
// dir2 is a directory that contains file3.txt, file4.txt
// dir3 is a directory that contains file5.txt
// dir4 does not exist

const files = ['dir1/file1.txt','dir2','dir4']

// asynchronous function that detects file type as none, file, or directory
function detectFile(file, callback) {
    fs.stat(file, function(err, stat) {
        if (err) {
            return callback(null, 'none');
        }
        callback(null, stat.isDirectory() ? 'directory' : 'file');
    });
}

//Using callbacks
async.groupBy(files, detectFile, function(err, result) {
    if(err) {
        console.log(err);
    } else {
	       console.log(result);
        // {
        //     file: [ 'dir1/file1.txt' ],
        //     none: [ 'dir4' ],
        //     directory: [ 'dir2']
        // }
        // result is object containing the files grouped by type
    }
});

// Using Promises
async.groupBy(files, detectFile)
.then( result => {
    console.log(result);
    // {
    //     file: [ 'dir1/file1.txt' ],
    //     none: [ 'dir4' ],
    //     directory: [ 'dir2']
    // }
    // result is object containing the files grouped by type
}).catch( err => {
    console.log(err);
});

// Using async/await
async () => {
    try {
        let result = await async.groupBy(files, detectFile);
        console.log(result);
        // {
        //     file: [ 'dir1/file1.txt' ],
        //     none: [ 'dir4' ],
        //     directory: [ 'dir2']
        // }
        // result is object containing the files grouped by type
    }
    catch (err) {
        console.log(err);
    }
}

Source:

• groupBy.js, line 3

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

import groupByLimit from 'async/groupByLimit';

Parameters:

Returns:

Type

Promise

Source:

• groupByLimit.js, line 5

See:

• async.groupBy

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

import groupBySeries from 'async/groupBySeries';

Parameters:

Returns:

Type

Promise

Source:

• groupBySeries.js, line 3

See:

• async.groupBy

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

import map from 'async/map';

Parameters:

Returns:

Type

Promise

Example

// file1.txt is a file that is 1000 bytes in size
// file2.txt is a file that is 2000 bytes in size
// file3.txt is a file that is 3000 bytes in size
// file4.txt does not exist

const fileList = ['file1.txt','file2.txt','file3.txt'];
const withMissingFileList = ['file1.txt','file2.txt','file4.txt'];

// asynchronous function that returns the file size in bytes
function getFileSizeInBytes(file, callback) {
    fs.stat(file, function(err, stat) {
        if (err) {
            return callback(err);
        }
        callback(null, stat.size);
    });
}

// Using callbacks
async.map(fileList, getFileSizeInBytes, function(err, results) {
    if (err) {
        console.log(err);
    } else {
        console.log(results);
        // results is now an array of the file size in bytes for each file, e.g.
        // [ 1000, 2000, 3000]
    }
});

// Error Handling
async.map(withMissingFileList, getFileSizeInBytes, function(err, results) {
    if (err) {
        console.log(err);
        // [ Error: ENOENT: no such file or directory ]
    } else {
        console.log(results);
    }
});

// Using Promises
async.map(fileList, getFileSizeInBytes)
.then( results => {
    console.log(results);
    // results is now an array of the file size in bytes for each file, e.g.
    // [ 1000, 2000, 3000]
}).catch( err => {
    console.log(err);
});

// Error Handling
async.map(withMissingFileList, getFileSizeInBytes)
.then( results => {
    console.log(results);
}).catch( err => {
    console.log(err);
    // [ Error: ENOENT: no such file or directory ]
});

// Using async/await
async () => {
    try {
        let results = await async.map(fileList, getFileSizeInBytes);
        console.log(results);
        // results is now an array of the file size in bytes for each file, e.g.
        // [ 1000, 2000, 3000]
    }
    catch (err) {
        console.log(err);
    }
}

// Error Handling
async () => {
    try {
        let results = await async.map(withMissingFileList, getFileSizeInBytes);
        console.log(results);
    }
    catch (err) {
        console.log(err);
        // [ Error: ENOENT: no such file or directory ]
    }
}

Source:

• map.js, line 5

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

import mapLimit from 'async/mapLimit';

Parameters:

Returns:

Type

Promise

Source:

• mapLimit.js, line 5

See:

• async.map

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

import mapSeries from 'async/mapSeries';

Parameters:

Returns:

Type

Promise

Source:

• mapSeries.js, line 5

See:

• async.map

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

import mapValues from 'async/mapValues';

Parameters:

Returns:

Type

Promise

Example

// file1.txt is a file that is 1000 bytes in size
// file2.txt is a file that is 2000 bytes in size
// file3.txt is a file that is 3000 bytes in size
// file4.txt does not exist

const fileMap = {
    f1: 'file1.txt',
    f2: 'file2.txt',
    f3: 'file3.txt'
};

const withMissingFileMap = {
    f1: 'file1.txt',
    f2: 'file2.txt',
    f3: 'file4.txt'
};

// asynchronous function that returns the file size in bytes
function getFileSizeInBytes(file, key, callback) {
    fs.stat(file, function(err, stat) {
        if (err) {
            return callback(err);
        }
        callback(null, stat.size);
    });
}

// Using callbacks
async.mapValues(fileMap, getFileSizeInBytes, function(err, result) {
    if (err) {
        console.log(err);
    } else {
        console.log(result);
        // result is now a map of file size in bytes for each file, e.g.
        // {
        //     f1: 1000,
        //     f2: 2000,
        //     f3: 3000
        // }
    }
});

// Error handling
async.mapValues(withMissingFileMap, getFileSizeInBytes, function(err, result) {
    if (err) {
        console.log(err);
        // [ Error: ENOENT: no such file or directory ]
    } else {
        console.log(result);
    }
});

// Using Promises
async.mapValues(fileMap, getFileSizeInBytes)
.then( result => {
    console.log(result);
    // result is now a map of file size in bytes for each file, e.g.
    // {
    //     f1: 1000,
    //     f2: 2000,
    //     f3: 3000
    // }
}).catch (err => {
    console.log(err);
});

// Error Handling
async.mapValues(withMissingFileMap, getFileSizeInBytes)
.then( result => {
    console.log(result);
}).catch (err => {
    console.log(err);
    // [ Error: ENOENT: no such file or directory ]
});

// Using async/await
async () => {
    try {
        let result = await async.mapValues(fileMap, getFileSizeInBytes);
        console.log(result);
        // result is now a map of file size in bytes for each file, e.g.
        // {
        //     f1: 1000,
        //     f2: 2000,
        //     f3: 3000
        // }
    }
    catch (err) {
        console.log(err);
    }
}

// Error Handling
async () => {
    try {
        let result = await async.mapValues(withMissingFileMap, getFileSizeInBytes);
        console.log(result);
    }
    catch (err) {
        console.log(err);
        // [ Error: ENOENT: no such file or directory ]
    }
}

Source:

• mapValues.js, line 3

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

import mapValuesLimit from 'async/mapValuesLimit';

Parameters:

Returns:

Type

Promise

Source:

• mapValuesLimit.js, line 6

See:

• async.mapValues

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

import mapValuesSeries from 'async/mapValuesSeries';

Parameters:

Returns:

Type

Promise

Source:

• mapValuesSeries.js, line 3

See:

• async.mapValues

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

import reduce from 'async/reduce';

Alias:

• foldl

Parameters:

Returns:

Type

Promise

Example

// file1.txt is a file that is 1000 bytes in size
// file2.txt is a file that is 2000 bytes in size
// file3.txt is a file that is 3000 bytes in size
// file4.txt does not exist

const fileList = ['file1.txt','file2.txt','file3.txt'];
const withMissingFileList = ['file1.txt','file2.txt','file3.txt', 'file4.txt'];

// asynchronous function that computes the file size in bytes
// file size is added to the memoized value, then returned
function getFileSizeInBytes(memo, file, callback) {
    fs.stat(file, function(err, stat) {
        if (err) {
            return callback(err);
        }
        callback(null, memo + stat.size);
    });
}

// Using callbacks
async.reduce(fileList, 0, getFileSizeInBytes, function(err, result) {
    if (err) {
        console.log(err);
    } else {
        console.log(result);
        // 6000
        // which is the sum of the file sizes of the three files
    }
});

// Error Handling
async.reduce(withMissingFileList, 0, getFileSizeInBytes, function(err, result) {
    if (err) {
        console.log(err);
        // [ Error: ENOENT: no such file or directory ]
    } else {
        console.log(result);
    }
});

// Using Promises
async.reduce(fileList, 0, getFileSizeInBytes)
.then( result => {
    console.log(result);
    // 6000
    // which is the sum of the file sizes of the three files
}).catch( err => {
    console.log(err);
});

// Error Handling
async.reduce(withMissingFileList, 0, getFileSizeInBytes)
.then( result => {
    console.log(result);
}).catch( err => {
    console.log(err);
    // [ Error: ENOENT: no such file or directory ]
});

// Using async/await
async () => {
    try {
        let result = await async.reduce(fileList, 0, getFileSizeInBytes);
        console.log(result);
        // 6000
        // which is the sum of the file sizes of the three files
    }
    catch (err) {
        console.log(err);
    }
}

// Error Handling
async () => {
    try {
        let result = await async.reduce(withMissingFileList, 0, getFileSizeInBytes);
        console.log(result);
    }
    catch (err) {
        console.log(err);
        // [ Error: ENOENT: no such file or directory ]
    }
}

Source:

• reduce.js, line 6

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

import reduceRight from 'async/reduceRight';

Alias:

• foldr

Parameters:

Returns:

Type

Promise

Source:

• reduceRight.js, line 3

See:

• async.reduce

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

import reject from 'async/reject';

Parameters:

Returns:

Type

Promise

Example

// dir1 is a directory that contains file1.txt, file2.txt
// dir2 is a directory that contains file3.txt, file4.txt
// dir3 is a directory that contains file5.txt

const fileList = ['dir1/file1.txt','dir2/file3.txt','dir3/file6.txt'];

// asynchronous function that checks if a file exists
function fileExists(file, callback) {
   fs.access(file, fs.constants.F_OK, (err) => {
       callback(null, !err);
   });
}

// Using callbacks
async.reject(fileList, fileExists, function(err, results) {
   // [ 'dir3/file6.txt' ]
   // results now equals an array of the non-existing files
});

// Using Promises
async.reject(fileList, fileExists)
.then( results => {
    console.log(results);
    // [ 'dir3/file6.txt' ]
    // results now equals an array of the non-existing files
}).catch( err => {
    console.log(err);
});

// Using async/await
async () => {
    try {
        let results = await async.reject(fileList, fileExists);
        console.log(results);
        // [ 'dir3/file6.txt' ]
        // results now equals an array of the non-existing files
    }
    catch (err) {
        console.log(err);
    }
}

Source:

• reject.js, line 5

See:

• async.filter

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

import rejectLimit from 'async/rejectLimit';

Parameters:

Returns:

Type

Promise

Source:

• rejectLimit.js, line 4

See:

• async.reject

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

import rejectSeries from 'async/rejectSeries';

Parameters:

Returns:

Type

Promise

Source:

• rejectSeries.js, line 5

See:

• async.reject

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

import some from 'async/some';

Alias:

• any

Parameters:

Returns:

Type

Promise

Example

// dir1 is a directory that contains file1.txt, file2.txt
// dir2 is a directory that contains file3.txt, file4.txt
// dir3 is a directory that contains file5.txt
// dir4 does not exist

// asynchronous function that checks if a file exists
function fileExists(file, callback) {
   fs.access(file, fs.constants.F_OK, (err) => {
       callback(null, !err);
   });
}

// Using callbacks
async.some(['dir1/missing.txt','dir2/missing.txt','dir3/file5.txt'], fileExists,
   function(err, result) {
       console.log(result);
       // true
       // result is true since some file in the list exists
   }
);

async.some(['dir1/missing.txt','dir2/missing.txt','dir4/missing.txt'], fileExists,
   function(err, result) {
       console.log(result);
       // false
       // result is false since none of the files exists
   }
);

// Using Promises
async.some(['dir1/missing.txt','dir2/missing.txt','dir3/file5.txt'], fileExists)
.then( result => {
    console.log(result);
    // true
    // result is true since some file in the list exists
}).catch( err => {
    console.log(err);
});

async.some(['dir1/missing.txt','dir2/missing.txt','dir4/missing.txt'], fileExists)
.then( result => {
    console.log(result);
    // false
    // result is false since none of the files exists
}).catch( err => {
    console.log(err);
});

// Using async/await
async () => {
    try {
        let result = await async.some(['dir1/missing.txt','dir2/missing.txt','dir3/file5.txt'], fileExists);
        console.log(result);
        // true
        // result is true since some file in the list exists
    }
    catch (err) {
        console.log(err);
    }
}

async () => {
    try {
        let result = await async.some(['dir1/missing.txt','dir2/missing.txt','dir4/missing.txt'], fileExists);
        console.log(result);
        // false
        // result is false since none of the files exists
    }
    catch (err) {
        console.log(err);
    }
}

Source:

• some.js, line 5

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

import someLimit from 'async/someLimit';

Alias:

• anyLimit

Parameters:

Returns:

Type

Promise

Source:

• someLimit.js, line 5

See:

• async.some

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

import someSeries from 'async/someSeries';

Alias:

• anySeries

Parameters:

Returns:

Type

Promise

Source:

• someSeries.js, line 5

See:

• async.some

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

import sortBy from 'async/sortBy';

Parameters:

Returns:

Type

Promise

Example

// bigfile.txt is a file that is 251100 bytes in size
// mediumfile.txt is a file that is 11000 bytes in size
// smallfile.txt is a file that is 121 bytes in size

// asynchronous function that returns the file size in bytes
function getFileSizeInBytes(file, callback) {
    fs.stat(file, function(err, stat) {
        if (err) {
            return callback(err);
        }
        callback(null, stat.size);
    });
}

// Using callbacks
async.sortBy(['mediumfile.txt','smallfile.txt','bigfile.txt'], getFileSizeInBytes,
    function(err, results) {
        if (err) {
            console.log(err);
        } else {
            console.log(results);
            // results is now the original array of files sorted by
            // file size (ascending by default), e.g.
            // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']
        }
    }
);

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

// ascending order
async.sortBy(['mediumfile.txt','smallfile.txt','bigfile.txt'], function(file, callback) {
    getFileSizeInBytes(file, function(getFileSizeErr, fileSize) {
        if (getFileSizeErr) return callback(getFileSizeErr);
        callback(null, fileSize);
    });
}, function(err, results) {
        if (err) {
            console.log(err);
        } else {
            console.log(results);
            // results is now the original array of files sorted by
            // file size (ascending by default), e.g.
            // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']
        }
    }
);

// descending order
async.sortBy(['bigfile.txt','mediumfile.txt','smallfile.txt'], function(file, callback) {
    getFileSizeInBytes(file, function(getFileSizeErr, fileSize) {
        if (getFileSizeErr) {
            return callback(getFileSizeErr);
        }
        callback(null, fileSize * -1);
    });
}, function(err, results) {
        if (err) {
            console.log(err);
        } else {
            console.log(results);
            // results is now the original array of files sorted by
            // file size (ascending by default), e.g.
            // [ 'bigfile.txt', 'mediumfile.txt', 'smallfile.txt']
        }
    }
);

// Error handling
async.sortBy(['mediumfile.txt','smallfile.txt','missingfile.txt'], getFileSizeInBytes,
    function(err, results) {
        if (err) {
            console.log(err);
            // [ Error: ENOENT: no such file or directory ]
        } else {
            console.log(results);
        }
    }
);

// Using Promises
async.sortBy(['mediumfile.txt','smallfile.txt','bigfile.txt'], getFileSizeInBytes)
.then( results => {
    console.log(results);
    // results is now the original array of files sorted by
    // file size (ascending by default), e.g.
    // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']
}).catch( err => {
    console.log(err);
});

// Error handling
async.sortBy(['mediumfile.txt','smallfile.txt','missingfile.txt'], getFileSizeInBytes)
.then( results => {
    console.log(results);
}).catch( err => {
    console.log(err);
    // [ Error: ENOENT: no such file or directory ]
});

// Using async/await
(async () => {
    try {
        let results = await async.sortBy(['bigfile.txt','mediumfile.txt','smallfile.txt'], getFileSizeInBytes);
        console.log(results);
        // results is now the original array of files sorted by
        // file size (ascending by default), e.g.
        // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']
    }
    catch (err) {
        console.log(err);
    }
})();

// Error handling
async () => {
    try {
        let results = await async.sortBy(['missingfile.txt','mediumfile.txt','smallfile.txt'], getFileSizeInBytes);
        console.log(results);
    }
    catch (err) {
        console.log(err);
        // [ Error: ENOENT: no such file or directory ]
    }
}

Source:

• sortBy.js, line 5

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

import transform from 'async/transform';

Parameters:

Returns:

Type

Promise

Examples

// file1.txt is a file that is 1000 bytes in size
// file2.txt is a file that is 2000 bytes in size
// file3.txt is a file that is 3000 bytes in size

// helper function that returns human-readable size format from bytes
function formatBytes(bytes, decimals = 2) {
  // implementation not included for brevity
  return humanReadbleFilesize;
}

const fileList = ['file1.txt','file2.txt','file3.txt'];

// asynchronous function that returns the file size, transformed to human-readable format
// e.g. 1024 bytes = 1KB, 1234 bytes = 1.21 KB, 1048576 bytes = 1MB, etc.
function transformFileSize(acc, value, key, callback) {
    fs.stat(value, function(err, stat) {
        if (err) {
            return callback(err);
        }
        acc[key] = formatBytes(stat.size);
        callback(null);
    });
}

// Using callbacks
async.transform(fileList, transformFileSize, function(err, result) {
    if(err) {
        console.log(err);
    } else {
        console.log(result);
        // [ '1000 Bytes', '1.95 KB', '2.93 KB' ]
    }
});

// Using Promises
async.transform(fileList, transformFileSize)
.then(result => {
    console.log(result);
    // [ '1000 Bytes', '1.95 KB', '2.93 KB' ]
}).catch(err => {
    console.log(err);
});

// Using async/await
(async () => {
    try {
        let result = await async.transform(fileList, transformFileSize);
        console.log(result);
        // [ '1000 Bytes', '1.95 KB', '2.93 KB' ]
    }
    catch (err) {
        console.log(err);
    }
})();

// file1.txt is a file that is 1000 bytes in size
// file2.txt is a file that is 2000 bytes in size
// file3.txt is a file that is 3000 bytes in size

// helper function that returns human-readable size format from bytes
function formatBytes(bytes, decimals = 2) {
  // implementation not included for brevity
  return humanReadbleFilesize;
}

const fileMap = { f1: 'file1.txt', f2: 'file2.txt', f3: 'file3.txt' };

// asynchronous function that returns the file size, transformed to human-readable format
// e.g. 1024 bytes = 1KB, 1234 bytes = 1.21 KB, 1048576 bytes = 1MB, etc.
function transformFileSize(acc, value, key, callback) {
    fs.stat(value, function(err, stat) {
        if (err) {
            return callback(err);
        }
        acc[key] = formatBytes(stat.size);
        callback(null);
    });
}

// Using callbacks
async.transform(fileMap, transformFileSize, function(err, result) {
    if(err) {
        console.log(err);
    } else {
        console.log(result);
        // { f1: '1000 Bytes', f2: '1.95 KB', f3: '2.93 KB' }
    }
});

// Using Promises
async.transform(fileMap, transformFileSize)
.then(result => {
    console.log(result);
    // { f1: '1000 Bytes', f2: '1.95 KB', f3: '2.93 KB' }
}).catch(err => {
    console.log(err);
});

// Using async/await
async () => {
    try {
        let result = await async.transform(fileMap, transformFileSize);
        console.log(result);
        // { f1: '1000 Bytes', f2: '1.95 KB', f3: '2.93 KB' }
    }
    catch (err) {
        console.log(err);
    }
}

Source:

• transform.js, line 6

Methods

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

import applyEach from 'async/applyEach';

Parameters:

Returns:

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:

• applyEach.js, line 4

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

import applyEachSeries from 'async/applyEachSeries';

Parameters:

Returns:

Type

AsyncFunction

Source:

• applyEachSeries.js, line 4

See:

• async.applyEach

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

import auto from 'async/auto';

Parameters:

Returns:

Type

Promise

Example

//Using Callbacks
async.auto({
    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: ['get_data', 'make_folder', function(results, callback) {
        // 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) {
        // once the file is written let's email a link to it...
        callback(null, {'file':results.write_file, 'email':'user@example.com'});
    }]
}, function(err, results) {
    if (err) {
        console.log('err = ', err);
    }
    console.log('results = ', results);
    // results = {
    //     get_data: ['data', 'converted to array']
    //     make_folder; 'folder',
    //     write_file: 'filename'
    //     email_link: { file: 'filename', email: 'user@example.com' }
    // }
});

//Using Promises
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) {
        // 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) {
        // once the file is written let's email a link to it...
        callback(null, {'file':results.write_file, 'email':'user@example.com'});
    }]
}).then(results => {
    console.log('results = ', results);
    // results = {
    //     get_data: ['data', 'converted to array']
    //     make_folder; 'folder',
    //     write_file: 'filename'
    //     email_link: { file: 'filename', email: 'user@example.com' }
    // }
}).catch(err => {
    console.log('err = ', err);
});

//Using async/await
async () => {
    try {
        let results = await async.auto({
            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: ['get_data', 'make_folder', function(results, callback) {
                // 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) {
                // once the file is written let's email a link to it...
                callback(null, {'file':results.write_file, 'email':'user@example.com'});
            }]
        });
        console.log('results = ', results);
        // results = {
        //     get_data: ['data', 'converted to array']
        //     make_folder; 'folder',
        //     write_file: 'filename'
        //     email_link: { file: 'filename', email: 'user@example.com' }
        // }
    }
    catch (err) {
        console.log(err);
    }
}

Source:

• auto.js, line 6

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

import autoInject from 'async/autoInject';

Parameters:

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:

• autoInject.js, line 51

See:

• async.auto

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

import cargo from 'async/cargo';

Parameters:

Returns:

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:

• cargo.js, line 3

See:

• async.queue

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

import cargoQueue from 'async/cargoQueue';

Parameters:

Returns:

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:

• cargoQueue.js, line 3

See:

• async.queue

• async.cargo

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

Source:

• compose.js, line 3

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

import doUntil from 'async/doUntil';

Parameters:

Returns:

Type

Promise

Source:

• doUntil.js, line 4

See:

• async.doWhilst

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

import doWhilst from 'async/doWhilst';

Parameters:

Returns:

Type

Promise

Source:

• doWhilst.js, line 5

See:

• async.whilst

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

import forever from 'async/forever';

Parameters:

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:

• forever.js, line 6

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

import parallel from 'async/parallel';

Parameters:

Returns:

Type

Promise

Example

//Using Callbacks
async.parallel([
    function(callback) {
        setTimeout(function() {
            callback(null, 'one');
        }, 200);
    },
    function(callback) {
        setTimeout(function() {
            callback(null, 'two');
        }, 100);
    }
], function(err, results) {
    console.log(results);
    // results is equal to ['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) {
    console.log(results);
    // results is equal to: { one: 1, two: 2 }
});

//Using Promises
async.parallel([
    function(callback) {
        setTimeout(function() {
            callback(null, 'one');
        }, 200);
    },
    function(callback) {
        setTimeout(function() {
            callback(null, 'two');
        }, 100);
    }
]).then(results => {
    console.log(results);
    // results is equal to ['one','two'] even though
    // the second function had a shorter timeout.
}).catch(err => {
    console.log(err);
});

// 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);
    }
}).then(results => {
    console.log(results);
    // results is equal to: { one: 1, two: 2 }
}).catch(err => {
    console.log(err);
});

//Using async/await
async () => {
    try {
        let results = await async.parallel([
            function(callback) {
                setTimeout(function() {
                    callback(null, 'one');
                }, 200);
            },
            function(callback) {
                setTimeout(function() {
                    callback(null, 'two');
                }, 100);
            }
        ]);
        console.log(results);
        // results is equal to ['one','two'] even though
        // the second function had a shorter timeout.
    }
    catch (err) {
        console.log(err);
    }
}

// an example using an object instead of an array
async () => {
    try {
        let results = await async.parallel({
            one: function(callback) {
                setTimeout(function() {
                    callback(null, 1);
                }, 200);
            },
           two: function(callback) {
                setTimeout(function() {
                    callback(null, 2);
                }, 100);
           }
        });
        console.log(results);
        // results is equal to: { one: 1, two: 2 }
    }
    catch (err) {
        console.log(err);
    }
}

Source:

• parallel.js, line 4

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

import parallelLimit from 'async/parallelLimit';

Parameters:

Returns:

Type

Promise

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 4

See:

• async.queue

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

import queue from 'async/queue';

Parameters:

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:

• queue.js, line 89

(static) race(tasks, callback) → {Promise}

import race from 'async/race';

Parameters:

Returns:

Type

Promise

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:

• race.js, line 5

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

import retry from 'async/retry';

Parameters:

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:

• retry.js, line 10

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 6

See:

• async.retry

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

import seq from 'async/seq';

Parameters:

Returns:

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(
        User.get.bind(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:

• seq.js, line 5

See:

• async.compose

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

import series from 'async/series';

Parameters:

Returns:

Type

Promise

Example

//Using Callbacks
async.series([
    function(callback) {
        setTimeout(function() {
            // do some async task
            callback(null, 'one');
        }, 200);
    },
    function(callback) {
        setTimeout(function() {
            // then do another async task
            callback(null, 'two');
        }, 100);
    }
], function(err, results) {
    console.log(results);
    // results is equal to ['one','two']
});

// an example using objects instead of arrays
async.series({
    one: function(callback) {
        setTimeout(function() {
            // do some async task
            callback(null, 1);
        }, 200);
    },
    two: function(callback) {
        setTimeout(function() {
            // then do another async task
            callback(null, 2);
        }, 100);
    }
}, function(err, results) {
    console.log(results);
    // results is equal to: { one: 1, two: 2 }
});

//Using Promises
async.series([
    function(callback) {
        setTimeout(function() {
            callback(null, 'one');
        }, 200);
    },
    function(callback) {
        setTimeout(function() {
            callback(null, 'two');
        }, 100);
    }
]).then(results => {
    console.log(results);
    // results is equal to ['one','two']
}).catch(err => {
    console.log(err);
});

// an example using an object instead of an array
async.series({
    one: function(callback) {
        setTimeout(function() {
            // do some async task
            callback(null, 1);
        }, 200);
    },
    two: function(callback) {
        setTimeout(function() {
            // then do another async task
            callback(null, 2);
        }, 100);
    }
}).then(results => {
    console.log(results);
    // results is equal to: { one: 1, two: 2 }
}).catch(err => {
    console.log(err);
});

//Using async/await
async () => {
    try {
        let results = await async.series([
            function(callback) {
                setTimeout(function() {
                    // do some async task
                    callback(null, 'one');
                }, 200);
            },
            function(callback) {
                setTimeout(function() {
                    // then do another async task
                    callback(null, 'two');
                }, 100);
            }
        ]);
        console.log(results);
        // results is equal to ['one','two']
    }
    catch (err) {
        console.log(err);
    }
}

// an example using an object instead of an array
async () => {
    try {
        let results = await async.parallel({
            one: function(callback) {
                setTimeout(function() {
                    // do some async task
                    callback(null, 1);
                }, 200);
            },
           two: function(callback) {
                setTimeout(function() {
                    // then do another async task
                    callback(null, 2);
                }, 100);
           }
        });
        console.log(results);
        // results is equal to: { one: 1, two: 2 }
    }
    catch (err) {
        console.log(err);
    }
}

Source:

• series.js, line 4

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

import times from 'async/times';

Parameters:

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:

• times.js, line 3

See:

• async.map

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

import timesLimit from 'async/timesLimit';

Parameters:

Returns:

Type

Promise

Source:

• timesLimit.js, line 5

See:

• async.times

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

import timesSeries from 'async/timesSeries';

Parameters:

Returns:

Type

Promise

Source:

• timesSeries.js, line 3

See:

• async.times

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

import tryEach from 'async/tryEach';

Parameters:

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:

• tryEach.js, line 5

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

import until from 'async/until';

Parameters:

Returns:

Type

Promise

Example

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

Source:

• until.js, line 4

See:

• async.whilst

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

import waterfall from 'async/waterfall';

Parameters:

Returns:

Type

Promise

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:

• waterfall.js, line 6

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

import whilst from 'async/whilst';

Parameters:

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:

• whilst.js, line 5

Type Definitions

QueueObject

import queue from 'async/queue';

Type:

• Iterable

Properties:

Source:

• queue.js, line 4

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

Methods

(static) apply(fn) → {function}

import apply from 'async/apply';

Parameters:

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:

• apply.js, line 1

(static) asyncify(func) → {AsyncFunction}

import asyncify from 'async/asyncify';

Alias:

• wrapSync

Parameters:

Returns:

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:

• 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 1

(static) dir(function)

import dir from 'async/dir';

Parameters:

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:

• 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]); // 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:

• ensureAsync.js, line 4

(static) log(function)

import log from 'async/log';

Parameters:

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:

• 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 can now be used as if it were slow_fn
fn('some name', function() {
    // callback
});

Source:

• memoize.js, line 5

(static) nextTick(callback)

import nextTick from 'async/nextTick';

Parameters:

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:

• nextTick.js, line 4

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 4

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

// 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:

• reflectAll.js, line 3

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 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:

• 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) {
        // 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:

• 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