प्रत्येक लूप के लिए जावास्क्रिप्ट सीमित करना

एक लूप में देरी करने के लिए, सबसे पहले, आपका कार्य async होना चाहिए।

फिर आप उस वादे का प्रतीक्षा कर सकते हैं जो 2 सेकंड के बाद हल हो जाता है। इस तरह की देरी को इस तरह एक-लाइनर के रूप में डाला जा सकता है:

await new Promise(resolve => setTimeout(resolve, 2000));

या एक आसान कार्य के रूप में:

const delay = time => new Promise(resolve => setTimeout(resolve, time));

... जिसे तब लूप में इस्तेमाल किया जा सकता है जैसे:

async function fetchEverything() {
   for (let thing of things) {
      await fetchThing(thing);
      await delay(2000);
   }
}

आप Array पर एक सामान्य एक्सटेंशन बना सकते हैं जो प्रत्येक पुनरावृत्ति के बीच में देरी डाल सकता है, आप फ़ंक्शन को async बनाना चाहेंगे ताकि आप इसका इंतजार कर सकें (और इसलिए जानें कि यह कब समाप्त हो गया है)।

Array.prototype.forEachLimited = async function(fn, timeBetweenCallsMs){
    
    const delay = async () => new Promise(resolve => setTimeout(resolve, timeBetweenCallsMs));
    
    for(var i=0;i<this.length;i++){
      fn(this[i]);
      await delay();
    }
};


(async function(){
  var myArr = [1,2,3,4,5];
  await myArr.forEachLimited(i => console.log(i), 2000);
  console.log("Finished");
})();

कुछ लोग इसे Array.prototype में जोड़ने पर नाराज हो सकते हैं, यह सरणी को तर्क के रूप में लेते हुए सामान्य कार्य के रूप में काम करेगा, इसलिए इसे Array.prototype में जोड़े बिना भी वही काम करेगा।

async function forEachLimited(arr, fn, timeBetweenCallsMs) {

  const delay = async() => new Promise(resolve => setTimeout(resolve, timeBetweenCallsMs));

  for (var i = 0; i < arr.length; i++) {
    fn(arr[i]);
    await delay();
  }
};


(async function() {
  var myArr = [1, 2, 3, 4, 5];
  await forEachLimited(myArr, i => console.log(i), 2000);
  console.log("Finished");
})();