after

What is after?

The 'after' npm package is a small utility that helps manage asynchronous operations by executing a callback after a specified number of operations have completed. It is particularly useful for scenarios where you need to wait for multiple asynchronous tasks to finish before proceeding.

What are after's main functionalities?

Execute callback after multiple asynchronous operations

This feature allows you to specify a callback function that will be executed after a certain number of asynchronous operations have completed. In this example, the callback will be executed after three tasks have finished.

const after = require('after');

const done = after(3, () => {
  console.log('All tasks completed');
});

setTimeout(() => {
  console.log('Task 1 done');
  done();
}, 1000);

setTimeout(() => {
  console.log('Task 2 done');
  done();
}, 2000);

setTimeout(() => {
  console.log('Task 3 done');
  done();
}, 3000);

Other packages similar to after

async

The 'async' package provides a wide range of utilities for working with asynchronous JavaScript, including functions for parallel and series execution, queue management, and more. It is more feature-rich compared to 'after' and can handle more complex asynchronous workflows.

promise

The 'promise' package is a lightweight implementation of Promises/A+ that allows you to work with asynchronous operations in a more modern and flexible way compared to callbacks. It provides methods like 'all' and 'race' to manage multiple promises, making it a more versatile option than 'after'.

bluebird

The 'bluebird' package is a fully-featured Promise library that offers advanced features like cancellation, iteration methods, and more. It is more powerful and flexible than 'after', making it suitable for complex asynchronous workflows.

README

After

All the flow control you'll ever need

Status: production ready

Example

var after = require("after"),
    next = after(3, logItWorks);

next();
next();
next(); // it works

function logItWorks() {
    console.log("it works!");
}

Motivation

Minimal flow control. A lot of the libraries out there are over kill. I want a small tool that gives me fundamental concrete building blocks

Documentation

after(count, callback) ^link

after takes a count and a callback and returns a function next. The callback get's invoked when the next function is invoked count number of times. The callback aggregates the data given to next as un-ordered parameters.

var next = after(3, printData);

next("foo", "bar", { ... })
next({ ... });
next(42);

function printData() {
    for (var i = 0, len = arguments.length; i < len; i++) {
        console.log(arguments[i]);  
    }
    // in some order
    // 42
    // { ... }
    // [ "foo", "bar", { ... }]
}

Note that the internal counter is exposed as next.count so you can manually increment or decrement it in a dynamic fashion. This is useful for recursively algorithms that want to increment the counter.

after.unpack(arguments) ^link

Unpack data from after using a convention

var next = after(2, function () {
    var data = after.unpack(arguments); 
    /* data = { foo: "bar", baz: "boz"}; */
});

next("foo", "bar");
next("baz", "boz");

after set utilities

The following methods are asynchronous parallel versions of the Array.prototype methods.

They all take parameters (set, iterator, optionalContext, finishedCallback)

• set : the set to operate on
• iterator : iterator function that is called for every value in the set. iterator has multiple signatures. Either (callback) or (value, callback) or (value, index, callback) or (value, index, obj, callback). The last argument is always the callback. The callback should be invoked when your done iterating over that item. You may invoke the callback with (err, result)
• optionalContext : optional parameter, if given it will be the value of this inside the iterator
• finishedCallback : this callback is invoked when every iterator has invoked it's individual callback. It has a signature of (err, result). The err parameter is whatever passed an error first or null. The result parameter is specific to each set utility function

Note that reduce has an optionalInitialValue instead of an optionalContext.

Also reduce's signature is (memo, value, index, obj, callback) or any of the shorter forms like (memo, value, callback).

Apart from reduce and reduceRight all of these set iterators run their iterators in parallel over the set

after.forEach(set, iterator, optionalContext, finishedCallback) ^link

For .forEach the result parameter of the finishedCallback is always undefined.

var set = {
    google: googleUser,
    github: githubUser,
    facebook: facebookUser
};

after.forEach(set, synchronizeOAuth, finished)

function synchronizeOAuth(userObject, oAuthName, callback) {
    getOAuth(oAuthName).sychronize(userObject, callback);
}

function finished(err) {
    if (err) throw err;
}

after.map(set, iterator, optionalContext, finishedCallback) ^link

For .map the result parameter of the finishedCalllback is the object your mapping too.

map will return a result that either inherits from your objects prototype or is an array depending on whether the call value is an object or an array

var set = {
    google: googleUser,
    github: githubUser,
    facebook: facebookUser
};

after.map(set, getOAuthUser, finished);

function getOauthUser(userObject, oAuthName, callback) {
    getOAuth(oAuthName).getUser(userObject, callback);
}

function finished (err, oAuthUserObjects) {
    if (err) throw err;
    for (var service in oAuthUserObjects) {
        ...
    }
}

after.reduce(set, iterator, optionalInitialValue, finishedCallback) ^link

For .reduce the result parameter is the reduced value.

var set = {
    google: googleUser,
    github: githubUser,
    facebook: facebookUser
};

after.reduce(set, aggregateFriends, 0, finished);

function aggregateFriends(memo, userObject, oAuthName, callback) {
    getOAuth(oAuthName)
        .getNumberOfFriends(userObject, function (err, friends) {
            callback(err, friends + memo);
        });
}

function finished (err, numberOfFriends) {
    if (err) throw err;
    ...
}

after.reduceRight(...) ^link

.reduceRight is the same as reduce excepts runs over the object in reverse.

after.filter(set, iterator, optionalContext, finishedCallback) ^link

For .filter the result is the filtered object/array.

var set = {
    google: googleUser,
    github: githubUser,
    facebook: facebookUser
};

after.filter(set, isRegistered, finished);

function isRegistered(memo, userObject, oAuthName, callback) {
    getOAuth(oAuthName).userExists(userObject, callback);
}

function finished (err, usersThatExist) {
    if (err) throw err;
    ...
}

after.every(set, iterator, optionalContext, finishedCallback) ^link

Every passes true to the finished callback if every callback in the iteration passed true.

var set = {
    google: googleUser,
    github: githubUser,
    facebook: facebookUser
};

after.every(set, isRegistered, finished);

function isRegistered(memo, userObject, oAuthName, callback) {
    getOAuth(oAuthName).userExists(userObject, callback);
}

function finished (err, registeredOnAllServices) {
    if (err) throw err;
    ...
}

After.some(set, iterator, optionalContext, finishedCallback) ^link

Some passes false to the finished callback if every callback in the iteration passed false.

var set = {
    google: googleUser,
    github: githubUser,
    facebook: facebookUser
};

after.every(set, isRegistered, finished);

function isRegistered(memo, userObject, oAuthName, callback) {
    getOAuth(oAuthName).userExists(userObject, callback);
}

function finished (err, registeredOnAnyServices) {
    if (err) throw err;
    ...
}

Installation

npm install after

Tests

make test

Blog post

Flow control in node.js

Examples :

• Determining the end of asynchronous operations
• In javascript what are best practices for executing multiple asynchronous functions
• JavaScript performance long running tasks
• Synchronous database queries with node.js

Contributors

• Raynos

MIT Licenced