जावास्क्रिप्ट फ़ंक्शन कतार

Question

मेरे पास कई कार्य हैं जिन्हें उत्तराधिकार में चलाने की आवश्यकता है, लेकिन दूसरे के पूरा होने से पहले नहीं। मुझे पिछले कार्यों को सफलतापूर्वक पूरा करने के बाद ही चलाने के लिए इन कार्यों को कतारबद्ध करने का एक तरीका है। कोई विचार?

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

Answer 1

कि वास्तव में आप क्यों नहीं के रूप में आप एक कवर समारोह में सूचीबद्ध करके उनका, पता चला है करते हैं?

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

अपने कार्य AJAX कॉल में शामिल है, तो आप कॉलबैक कार्यों कि संभाल AJAX कॉल के अंत में उन्हें हुक करने की जरूरत है।

Answer 2

सुनिश्चित करें कि वे एक साथ चलेंगी बनाने के लिए, आप प्रत्येक एक और उपयोग है कि बाद में एक में मान दिया से एक मूल्य वापस कर सकती है ...

function do_1_to_5() { 

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

} 

Answer 3

आप कुछ इस तरह इस्तेमाल कर सकते हैं:

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

और इस तरह इसका इस्तेमाल: कुछ वर्षों के बाद

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

संपादित करें: लोग इसका अनुसरण कर रहे हैं एक और तरीका next फ़ंक्शन में पास करना है जिसे आप श्रृंखला जारी रखने के लिए कॉल कर सकते हैं। इसलिए जैसा:

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

आप एक पंक्ति समारोह बना सकते हैं:

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

तो अगर ये आपके कार्यों ...

function f1() { 
    alert(1); 
} 

function f2() { 
    alert(2); 
} 

function f3() { 
    alert(3); 
} 

... तुम सिर्फ उन्हें पारित (उनके संदर्भ थे) एक नई कतार के उदाहरण के अंदर:

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

तो फिर तुम callNext() निष्पादित कार्यों क्रमिक रूप से कॉल करने के लिए:

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

---

लाइव डेमो:http://jsfiddle.net/CEdPS/3/

Answer 5

आप सभी कि मशीनरी की जरूरत नहीं है, बस एक सरणी में अपने कार्यों डाल दिया। फिर आप उन पर लूप कर सकते हैं।

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

जावास्क्रिप्ट एकल पिरोया तो आप अगले शुरू होने से पहले एक खत्म की गारंटी कर रहे हैं।

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

या के बाद से अपने कार्यों नियतात्मक नाम है, तो आप सरणी पूरी तरह से बच सकते हैं:

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

Answer 6

async.js बाहर की जाँच करें - यह कार्यों को चेनिंग लिए एक तंत्र प्रदान ताकि वे अतुल्यकालिक रूप से या एक के बाद निष्पादित दूसरा, सभी निष्पादित कार्यों से परिणाम और/या त्रुटियों को पकड़ने के लिए एक शानदार तरीका है।

https://github.com/caolan/async