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

}

funcB = function() {

    //Does funcB stuff

    funcC();

}



funcA();

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;

}

myObj.funcA().funcB().funcC();

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?