eliminar - En JavaScript, cómo ejecutar la siguiente función desde una matriz de funciones

eliminar un elemento de un array javascript

Question

Tengo una serie de funciones, como en:

funcArray = [func1, func2, func3];

Cuando estoy en una función dada, quiero ejecutar la siguiente función en la matriz. ¿Cómo hago esto? Aquí está mi esqueleto básico:

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.
}

No puedo usar la función indexOf , como se haría para una matriz de cadenas o números. NOTA : Esta pregunta parece ser similar a this ya la que se refiere. Sin embargo, es una pregunta diferente.

Quiero alterar la secuencia de procesamiento simplemente modificando la matriz. Ese es el objetivo. Un enfoque posiblemente más eficiente sería apreciado.

Aclaración : Basado en algunos de los comentarios: funcArray es global.

El objetivo es implementar middleware para un módulo HTTP Node.js de la manera más simple y eficiente posible sin utilizar módulos de terceros.

Answer 1

A menos que func1 cierre sobre funcArray , no puede hacer que se func2 y encuentre func2 y lo ejecute, ni debería hacerlo usted. Incluso si func1 se cierra sobre funcArray , sería una separación pobre de preocupaciones para que func1 y se encuentre en funcArray y luego ejecute func2 .

En su lugar, tenga otro código que se encargue de ejecutar las funciones.

Si son sincrónicas

Si las funciones completan su trabajo de forma síncrona, entonces es simplemente:

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

o

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

o si el resultado de una función se pasa a la siguiente, puede usar reduce :

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

... donde undefined es el valor para pasar a func1 .

Si son asincronos

Si no realizan su trabajo de forma síncrona, deberá proporcionarles una manera de notificar a la persona que llama que han completado su trabajo. Las promesas son una buena forma estándar de hacerlo, pero en su lugar podría usar devoluciones de llamada simples.

Si haces promesas de devolución, por ejemplo, puedes usar el viejo truco de reduce promesa:

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

o si el resultado de una función se pasa a la siguiente:

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

Puede proporcionar un argumento a Promise.resolve para establecer el valor para pasar a func1 (sin uno, recibirá undefined ).

Answer 2

La respuesta aceptada y otros comentarios me ayudaron, pero la forma en que lo implementé es la siguiente:

//The functions are defined as variables.
//They do not get hoisted, so must be defined first.
func1 = function (arg1, arg2) {
//Code to do whatever...
...
//Execute the next function.
//The name of the function is returned by executing nextFunc()
global[nextFunc()](arg1, arg2, arg3);
}
func2 = function (arg1) { //Note different type of args
...
}
//Note that this is an array of strings representing function names.
funcArray = ["func1", "func2", "func3",...]
//Start the execution...
func1(arg1, arg2);
function nextFunc() {
var currentFuncName = nextFunc.caller.name;
var index = funcArray.indexOf(currentFuncName);
if (index < funcArray.length)
return funcArray[index+1];
}

La secuencia de funciones a ejecutar se gestiona fácilmente a través de la matriz funcArray. El número o tipo de argumentos no es fijo para cada función. Además, las funciones controlan si deben detener la cadena o continuar con la siguiente función.

Es muy simple de entender que requiere habilidades básicas de Javascript. No hay gastos generales de uso de promesas.

"global" se sustituye por "ventana" para el navegador. Esta es una implementación de Node.js. Sin embargo, el uso de nombres de funciones en la matriz se interrumpirá si minimiza el código JS. Como lo voy a usar en el servidor, no espero minificarlo.

Answer 3

No sé si sus funciones requieren ciertos parámetros, pero esto es lo primero que me vino a la mente.

var functArray = [
function() {
console.log("function1 executed");
},
function() {
console.log("function2 executed");
},
function() {
console.log("function3 executed");
},
function() {
console.log("function4 executed");
}];
functArray.forEach(function(x){
x();
});

Answer 4

Puede enlazar a la función el índice donde se encuentra en la matriz, de modo que puede usar este índice para obtener y llamar a la siguiente función:

var funcArray = [func1, func2];
var boundFuncArray = funcArray.map((f, i) => f.bind(null, i));
boundFuncArray[0]();
function func1(nextFunctionIndex) {
console.log(''func1 called'');
// Execute next function:
var nextFunc = boundFuncArray[nextFunctionIndex + 1];
nextFunc && nextFunc();
}
function func2(nextFunctionIndex) {
console.log(''func2 called'');
// Execute next function:
var nextFunc = boundFuncArray[nextFunctionIndex + 1];
nextFunc && nextFunc();
}

Como TJ Crowder declaró en el comentario a continuación, también puede vincular la siguiente función a la actual:

var funcArray = [func1, func2];
var boundFuncArray= funcArray.map((f, i, arr) => f.bind(null, arr[i + 1]));
boundFuncArray[0]();
function func1(nextFunc) {
console.log(''func1 called'');
// Execute next function:
nextFunc && nextFunc();
}
function func2(nextFunc ) {
console.log(''func2 called'');
// Execute next function:
nextFunc && nextFunc();
}

Answer 5

Puede obtener el nombre de la función actual con los arguments.callee.name , recorrer la matriz de funciones y llamar a la siguiente función:

funcArray = [func1, func2, func3];
// Only func1() and func2() will be documented since the others have repeating code
function func1() {
// show the current function name
console.log(arguments.callee.name);
// loop the array of functions
for(var i = 0; i < funcArray.length; ++i)
{
// when the current array item is our current function name and
// another function exists after this then call it and break
if(funcArray[i] === arguments.callee && funcArray[i+1])
{
funcArray[i+1]();
break;
}
}
}
function func2() {
console.log(arguments.callee.name);
// some logic which switches our next function to be func4()
funcArray[2] = func4;
for(var i = 0; i < funcArray.length; ++i)
{
if(funcArray[i] === arguments.callee && funcArray[i+1])
{
funcArray[i+1]();
break;
}
}
}
function func3() {
console.log(arguments.callee.name);
for(var i = 0; i < funcArray.length; ++i)
{
if(funcArray[i] === arguments.callee && funcArray[i+1])
{
funcArray[i+1]();
break;
}
}
}
function func4() {
console.log(arguments.callee.name);
for(var i = 0; i < funcArray.length; ++i)
{
if(funcArray[i] === arguments.callee && funcArray[i+1])
{
funcArray[i+1]();
break;
}
}
}
// call the first function
funcArray[0]();

Salida:

func1
func2
func4