Collections

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)

import detect from 'async/detect';

Alias:

• find

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

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

import detectLimit from 'async/detectLimit';

Alias:

• findLimit

Parameters:

Returns:

Source:

• detectLimit.js, line 5

See:

• async.detect

(static) detectSeries(coll, iteratee, callbackopt)

import detectSeries from 'async/detectSeries';

Alias:

• findSeries

Parameters:

Returns:

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