In JavaScript, how to execute next function from an array of functions

Question

I have an array of functions, as in:

funcArray = [func1, func2, func3];

When in a given function, I want to execute the next function in the array. How do I do this? Here is my basic skeleton:

function func1() {
  // I get current function caller
  var currentFunc = func1.caller;

  // I want to execute the next function. Happens to be func2 in the example.

}

I cannot use indexOf function, as one would for an array of strings or numbers. NOTE: This question appears to be similar to this and the one it refers to. However, it is a different question.

I want to alter the sequence of processing by merely modifying the array. That's the goal. A possibly more efficient approach would be appreciated.

Clarification: Based upon some of the comments: funcArray is global.

The goal is to implement middleware for a Node.js HTTP module in as simple and efficient a manner as possible without using any third-party modules.

Answer 1

Unless func1 closes over funcArray, you cannot have it reach out and find func2 and execute it, nor should you. Even if func1 does close over funcArray, it would be poor separation of concerns for func1 to reach out and find itself in funcArray and then execute func2.

Instead, have other code that's in charge of running the functions.

If they're synchronous

If the functions complete their work synchronously, then it's simply:

funcArray.forEach(fn => fn());

or

for (const fn of funcArray) {
    fn();
}

or if the result of one function should be passed to the next, you can use reduce:

const finalResult = funcArray.reduce((previousResult, fn) => fn(previousResult), undefined);

...where undefined is the value to pass to func1.

If they're asynchronous

If they don't do their work synchronously, you'll need to provide them a way to notify their caller that they've completed their work. Promises are a good, standard way to do that, but you could use simple callbacks instead.

If you make them return promises, for instance, you can use the old promise reduce trick:

funcArray.reduce((p, fn) => {
    return p.then(() => {
        fn();
    });
}, Promise.resolve());

or if the result of one function should be passed to the next:

funcArray.reduce((p, fn) => {
    return p.then(fn);
}, Promise.resolve());

You can provide an argument to Promise.resolve to set the value to pass to func1 (without one, it'll receive undefined).