JavaScript Function Queue

Question

Tengo un montón de funciones que deben ejecutarse en sucesión, pero no antes de que la otra se haya completado. Lo que necesito es una forma de poner en cola estas funciones para que se ejecuten solo después de que la función anterior se haya completado con éxito. ¿Algunas ideas?

Function1(); 
Function2(); 
Function3(); 
Function4(); 
Function5(); 

Answer 1

¿Por qué no haces exactamente lo que has mostrado al mostrarlos en una función de cobertura?

function do_1_to_5() { 
    Function1(); 
    Function2(); 
    Function3(); 
    Function4(); 
    Function5(); 
} 

Si su función contiene llamadas AJAX, entonces usted necesita para conectarlos al final de las funciones de devolución de llamada que manejan los llamadas AJAX.

Answer 2

Para asegurarse de que funcionan de forma consecutiva, es posible devolver un valor de cada uno y el uso que se volvió un valor en el posterior ...

function do_1_to_5() { 

    r1 = Function1(); 
    r2 = Function2(r1); 
    r3 = Function3(r2); 
    r4 = Function4(r3); 
    r5 = Function5(r4); 

} 

Answer 3

Usted podría utilizar algo como esto:

var FunctionQueue = (function(){ 
    var queue = []; 
    var add = function(fnc){ 
     queue.push(fnc); 
    }; 
    var goNext = function(){ 
     var fnc = queue.shift(); 
     fnc(); 
    }; 
    return { 
     add:add, 
     goNext:goNext 
    }; 
}()); 

y utilizar de esta manera:

var fnc1 = function(){ 
    window.setTimeout(function(){ 
     alert("1 done"); 
     FunctionQueue.goNext(); 
    }, 1000); 
}; 

var fnc2 = function(){ 
    window.setTimeout(function(){ 
     alert("2 done"); 
     FunctionQueue.goNext(); 
    }, 5000); 
}; 

var fnc3 = function(){ 
    window.setTimeout(function(){ 
     alert("3 done"); 
     FunctionQueue.goNext(); 
    }, 2000); 
}; 

FunctionQueue.add(fnc1); 
FunctionQueue.add(fnc2); 
FunctionQueue.add(fnc3); 
FunctionQueue.goNext(); 

Edición después de unos años: Otra forma en que las personas se acercan a esto es pasar una función next a la que puede llamar para continuar la cadena. De este modo:

var Queue = function(arr){ 
    var index = 0; 
    var next = function(){ 
     if (index >= arr.length) {return;} 
     arr[index++](next); 
    }; 
    return next; 
}; 

var fn1 = function(next){ 
    console.log("I am FN1"); 
    next(); 
}; 

var fn2 = function(next){ 
    console.log("I am FN2"); 
    setTimeout(next,1000); 
}; 

var fn3 = function(next){ 
    console.log("I am FN3"); 
    setTimeout(next,3000); 
}; 

var fn4 = function(next){ 
    console.log("I am FN4"); 
    setTimeout(next,1000); 
}; 

Queue([fn1, fn2, fn3, fn4])(); 

Answer 4

Se puede crear una función de cola:

function Queue(arr) { 
    var i = 0; 
    this.callNext = function() { 
     typeof arr[i] == 'function' && arr[i++](); 
    }; 
} 

Así que si estos eran sus funciones ...

function f1() { 
    alert(1); 
} 

function f2() { 
    alert(2); 
} 

function f3() { 
    alert(3); 
} 

... simplemente pasas ellos (sus referencias) dentro de una nueva instancia de Queue:

var queue = new Queue([f1, f2, f3]); 

A continuación se ejecuta callNext() a llamar a las funciones de forma secuencial:

queue.callNext(); 
queue.callNext(); 
queue.callNext(); 

---

en vivo de demostración:http://jsfiddle.net/CEdPS/3/

Answer 5

que no es necesario que todas las máquinas, sólo hay que poner sus funciones en una matriz. Entonces puedes recorrerlos.

var runThese = [ 
    Function1, 
    Function2, 
    Function3, 
    Function4, 
    Function5 
]; 

JavaScript es de subproceso único, por lo que está garantizado que uno termina antes de los próximos comienzos.

for (var i = 0; i < runThese.length; i++) { 
    runThese[i](); 
} 

O, ya que sus funciones tienen nombres deterministas, podría evitar por completo la matriz:

for (var i = 1; i <= 5; i++) { 
    window["Function" + String(i)](); 
} 

Answer 6

Echa un vistazo a async.js - que proporciona un mecanismo para encadenar hasta funciones para que ejecuten de forma asíncrona o uno después otro, con una excelente forma de detectar los resultados y/o errores de todas las funciones ejecutadas.

https://github.com/caolan/async