asyncSeries.js

Asynchronously process a list of items consecutively.

Even though the processing is asynchronous, it is never done in parallel.

Install

1npm i -S @duzun/async-series

Import or require

This library can be included either as an ESM or UMD.

ESM

1import {
2    forEach as eachSeries,
3    map     as mapSeries,
4    reduce  as reduceSeries
5} from '@duzun/async-series';

CommonJS

1const {
2    forEach: eachSeries,
3    map    : mapSeries,
4    reduce : reduceSeries,
5} = require('@duzun/async-series');

AMD

1require('https://unpkg.com/@duzun/async-series', (asyncSeries) => {
2    const {
3        forEach: eachSeries,
4        map    : mapSeries,
5        reduce : reduceSeries,
6    } = asyncSeries;
7
8    // ...
9});

Browser

1<script src="https://unpkg.com/@duzun/async-series"></script>
2<script>
3const {
4    forEach: eachSeries,
5    map    : mapSeries,
6    reduce : reduceSeries,
7} = asyncSeries;
8</script>

Usage by example

forEach(array, iteratee)

Where [async ]iteratee(value, index, array)

Process file contents of a directory, asynchronously & consecutively.

1const fs = require('mz/fs');
2const { forEach: eachSeries } = require('@duzun/async-series');
3
4(async () => {
5    let files = await fs.readdir('.');
6    let results = await eachSeries(files, async (filename, idx) => {
7        if((await fs.stat(filename)).isDirectory()) return;
8        let contents = await fs.readFile(filename);
9
10        // Do some heavy processing here...
11    });
12})();

map(array, iteratee[, firstValue])

Where [async ]iteratee(value, index, array)

Get file contents of a directory, asynchronously & consecutively;

1const fs = require('mz/fs');
2const { map: mapSeries } = require('@duzun/async-series');
3
4(async () => {
5    let files = await fs.readdir('.');
6    let contents = await mapSeries(files, async (filename, idx) => {
7        if((await fs.stat(filename)).isDirectory()) return;
8        return fs.readFile(filename, 'utf8');
9    });
10    contents = contents.filter((x) => x);
11})();

reduce(array, reducer[, initialValue])

Where [async ]reducer(accumulator, currentValue, index, array)

Calculate file sizes in a directory, asynchronously & consecutively.

1const fs = require('mz/fs');
2const { reduce: reduceSeries } = require('@duzun/async-series');
3
4(async () => {
5    let files = await fs.readdir('.');
6    let size = await reduceSeries(files, async (size, filename, idx) => {
7        let stats = await fs.stat(filename);
8        if(stats.isDirectory()) return size;
9        return size + stats.size;
10    }, 0);
11
12    console.log('size: ', size);
13})();
14

Why?

Why not? :)

I know, there is a great library Async.js, which already has eachSeries, mapSeries and reduce and many other functions.

This library is < 900 bytes minified, and < 500 bytes when also gzipped.

And if you include it with rollup.js, you only get the function you've imported.