Get Even More Visitors To Your Blog, Upgrade To A Business Listing >>

How to execute a Javascript function only after multiple other functions have completed?

How to execute a Javascript function only after multiple other functions have completed?


My specific problem is that I need to execute a (potentially) large number of Javascript functions to prepare something like a batch file (each Function call adds some information to the same batch file) and then, after all those calls are completed, execute a final function to send the batch file (say, send it as an HTML response). I'm looking for a general Javascript programming pattern for this.

Generalize problem: Given the Javascript functions funcA(), funcB(), and funcC(), I would to figure out the best way to order execution so that funcC is only executed after after Funca and funcB have executed. I know that I could use nested callback functions like this:

funcA = function() {
    //Does funcA stuff
funcB = function() {
    //Does funcB stuff


I could even make this pattern a little more general by passing in callback parameters, however, this solution becomes quite verbose.

I am also familiar with Javascript function chaining where a solution might look like:

myObj = {}
myObj.answer = ""
myObj.funcA = function() {
    //Do some work on this.answer
    return this;
myObj.funcB = function() {
    //Do some more work on this.answer
    return this;
myObj.funcC = function() {
    //Use the value of this.answer now that funcA and funcB have made their modifications
    return this;

While this solution seems a little cleaner to me, as you add more steps to the computation, the chain of function executions grows longer and longer.

For my specific problem, the order in which funcA, funcB, etc. are executed DOES NOT matter. So in my solutions above, I am technically doing more work than is required because I am placing all the functions in a serial ordering. All that matters to me is that funcC (some function for sending the result or firing off a request) is only called after funcA and funcB have ALL completed execution. Ideally, funcC could somehow listen for all the intermediate function calls to complete and THEN would execute? I hoping to learn a general Javascript pattern to solve such a problem.

Thanks for your help.

Another Idea: Maybe pass a shared object to funcA and funcB and when they complete execution mark the shared object like sharedThing.funcA = "complete" or sharedThing.funcB = "complete" and then somehow? have funcC execute when the shared object reaches a state where all fields are marked complete. I'm not sure how exactly you could make funcC wait for this.

Edit: I should note that I'm using server-side Javascript (Node.js) and I would like to learn a pattern to solve it just using plain old Javascript (without the use of jQuery or other libraries). Surely this problem is general enough that there is a clean pure-Javascript solution?

Problem courtesy of: dghubble


If you want to keep it simple, you can use a counter-based callbacks system. Here's a draft of a system that allows when(A, B).then(C) syntax. (when/then is actually just sugar, but then again the whole system arguably is.)

var when = function() {
  var args = arguments;  // the functions to execute first
  return {
    then: function(done) {
      var counter = 0;
      for(var i = 0; i 


  function(done) {
    // do things
  function(done) {
    // do things
    setTimeout(done, 1000);
).then(function() {
  // all are done
Solution courtesy of: pimvdb


View additional discussion.

This post first appeared on Node.js Recipes, please read the originial post: here

Share the post

How to execute a Javascript function only after multiple other functions have completed?


Subscribe to Node.js Recipes

Get updates delivered right to your inbox!

Thank you for your subscription