Kolejka funkcji JavaScriptu

Question

Mam mnóstwo funkcji, które muszą być uruchamiane kolejno, ale nie wcześniej niż drugie. Potrzebuję sposobu na umieszczenie tych funkcji w kolejce, aby działały tylko po pomyślnym zakończeniu poprzedniej funkcji. Jakieś pomysły?

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

Answer 1

Dlaczego nie robisz dokładnie tak, jak pokazałeś, wymieniając je w funkcji pokrywającej?

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

Jeśli funkcja zawiera AJAX wzywa, to trzeba podłączyć je pod koniec funkcji zwrotnych, które obsługują AJAX wywołuje.

Answer 2

Aby upewnić się, że prowadzony kolejno, może zwrócić wartość z każdym z nich i stosowania, że ​​zwrócona wartość w kolejnym jednym ...

function do_1_to_5() { 

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

} 

Answer 3

Można użyć coś takiego:

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

i używać go tak:

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

Edit po kilku latach: Innym sposobem, w jaki ludzie się do tego zbliżają, jest przekazanie funkcji next, którą można wywołać, aby kontynuować łańcuch. Tak:

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

Można utworzyć funkcję kolejki:

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

Więc jeśli były twoje funkcje ...

function f1() { 
    alert(1); 
} 

function f2() { 
    alert(2); 
} 

function f3() { 
    alert(3); 
} 

... po prostu przekazać je (ich referencje) wewnątrz nowej instancji kolejki:

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

Następnie należy wykonać callNext() zadzwonić kolejno funkcje:

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

---

żywo Demo:http://jsfiddle.net/CEdPS/3/

Answer 5

Nie trzeba wszystko, że maszyna, wystarczy umieścić swoje funkcje w tablicy. Wtedy możesz je przerzucić.

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

JavaScript jest jednowątkowy, więc masz gwarancję, że skończysz przed następnymi uruchomieniami.

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

Albo skoro twoi funkcje mają nazwy deterministyczne, można uniknąć całkowicie tablicę:

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

Answer 6

odjazdu async.js - zapewnia mechanizm łączenia się funkcje więc wykonać asynchronicznie lub jeden po inny, z doskonałym sposobem przechwytywania wyników i/lub błędów ze wszystkich wykonywanych funkcji.

https://github.com/caolan/async