मैं जावास्क्रिप्ट लूप में देरी कैसे जोड़ूं?

Question

मैं एक whileलूप के अंदर देरी / नींद जोड़ना चाहता हूं :

मैंने इसे इस तरह आज़माया:

alert('hi');

for(var start = 1; start < 10; start++) {
  setTimeout(function () {
    alert('hello');
  }, 3000);
}

केवल पहला परिदृश्य सच है: दिखाने के बाद alert('hi'), यह 3 सेकंड के लिए इंतजार कर रहा है , फिर alert('hello')प्रदर्शित किया जाएगा लेकिन फिर alert('hello')लगातार दोहराया जाएगा।

जो मैं चाहूंगा वह यह है कि alert('hello')3 सेकंड दिखाए जाने के बाद alert('hi')उसके बाद दूसरी बार 3 सेकंड इंतजार करना होगा alert('hello')।

Answer 1

setTimeout()समारोह गैर अवरुद्ध है और तुरंत वापस आ जाएगी। इसलिए आपका लूप बहुत तेज़ी से पुनरावृत्त होगा और यह त्वरित उत्तराधिकार में एक के बाद एक 3-सेकंड टाइमआउट ट्रिगर शुरू करेगा। यही कारण है कि आपका पहला अलर्ट 3 सेकंड के बाद पॉप अप होता है, और बाकी सभी बिना किसी देरी के उत्तराधिकार में आते हैं।

आप इसके बजाय कुछ इस तरह का उपयोग करना चाह सकते हैं:

var i = 1;                  //  set your counter to 1

function myLoop() {         //  create a loop function
  setTimeout(function() {   //  call a 3s setTimeout when the loop is called
    console.log('hello');   //  your code here
    i++;                    //  increment the counter
    if (i < 10) {           //  if the counter < 10, call the loop function
      myLoop();             //  ..  again which will trigger another 
    }                       //  ..  setTimeout()
  }, 3000)
}

myLoop();                   //  start the loop

आप इसे स्वयं को लागू करने वाले फ़ंक्शन का उपयोग करके, तर्क के रूप में पुनरावृत्तियों की संख्या को पार करके भी इसे साफ कर सकते हैं:

(function myLoop(i) {
  setTimeout(function() {
    console.log('hello'); //  your code here                
    if (--i) myLoop(i);   //  decrement i and call myLoop again if i > 0
  }, 3000)
})(10);                   //  pass the number of iterations as an argument

Comments

इसे लागू करने के लिए पुनरावृत्ति का उपयोग नहीं किया जाएगा जो अंततः स्टैक ओवरफ्लो के अधीन होगा? यदि आप एक लाख पुनरावृत्तियों को करना चाहते हैं, तो इसे लागू करने का एक बेहतर तरीका क्या होगा? शायद सेटइंटरवल और फिर इसे साफ़ करें, जैसे हाबिल का समाधान नीचे?

— एडम

@ एडम: मेरी समझ यह है कि, चूंकि सेटटाइमआउट गैर-अवरोधक है, इसलिए यह पुनरावृत्ति नहीं है - प्रत्येक सेटटाइमआउट के बाद स्टैकविंडो बंद हो जाता है और निष्पादित करने के लिए केवल एक सेटटाइमआउट इंतजार कर रहा है ... सही?

— जो

for inपाश की तरह किसी वस्तु की पुनरावृति होने पर यह कैसे काम करेगा ?

— vsync

@vsync में देखेंObject.keys()

— ब्रैडेन बेस्ट

@joey आप भ्रमित कर रहे हैं setTimeoutके साथ setInterval। जब कॉलबैक कहा जाता है, तो टाइमआउट अंतर्निहित रूप से नष्ट हो जाते हैं।

— cdhowie

Answer 2

कुछ इस तरह की कोशिश करो:

var i = 0, howManyTimes = 10;
function f() {
    alert( "hi" );
    i++;
    if( i < howManyTimes ){
        setTimeout( f, 3000 );
    }
}
f();

Answer 3

ES6 का उपयोग करते हुए, आप letइसे प्राप्त करने के लिए उपयोग कर सकते हैं :

for (let i=1; i<10; i++) {
    setTimeout( function timer(){
        alert("hello world");
    }, i*3000 );
}

प्रत्येक पुनरावृत्ति के लिए क्या letघोषित होता है , लूप नहीं। इस तरह, जो बीत गया है, वही है जो हम चाहते हैं।isetTimeout

Comments

धन्यवाद! इस विधि के बारे में अपने दम पर नहीं सोचा होगा। वास्तविक ब्लॉक स्कूपिंग। कल्पना कीजिए कि ...

— सोफिया गोल्ड

मेरा मानना है कि इस के रूप में इस सवाल का जवाब में वर्णित एक ही स्मृति आवंटन मुद्दे हैं stackoverflow.com/a/3583795/1337392

— Flame_Phoenix

@Flame_Phoenix मेमोरी आवंटन समस्याएं क्या हैं?

— 4castle

सेटटाइमआउट कॉल i*3000, लूप के अंदर तर्क के मूल्य की गणना करता है , और इसे setTimeoutमान से पास करता है । letप्रश्न और उत्तर के वैकल्पिक और असंबंधित का उपयोग है।

— traktor53

@Flame_Phoenix ने इस कोड में समस्याएं बताई हैं। मूल रूप से पहले पास पर आप टाइमर बनाते हैं, फिर तुरंत लूप को फिर से और फिर से दोहराते हैं जब तक लूप एंड बाय कंडीशन ( i < 10) नहीं हो जाता है, इसलिए आपके पास समानांतर में कई टाइमर काम करेंगे जो मेमोरी एलोकेशन बनाते हैं और यह बड़ी मात्रा में पुनरावृत्तियों पर खराब होता है।

— XCANG

Answer 4

चूंकि ES7 एक लूप का इंतजार करने का एक बेहतर तरीका है :

// Returns a Promise that resolves after "ms" Milliseconds
function timer(ms) {
 return new Promise(res => setTimeout(res, ms));
}

async function load () { // We need to wrap the loop into an async function for this to work
  for (var i = 0; i < 3; i++) {
    console.log(i);
    await timer(3000); // then the created Promise can be awaited
  }
}

load();

जब इंजन awaitभाग में पहुंचता है , तो यह एक टाइमआउट सेट करता है और निष्पादन को रोक देता हैasync function । फिर जब समय समाप्त हो जाता है, तो उस बिंदु पर निष्पादन जारी रहता है। यह काफी उपयोगी है क्योंकि आप विलंबित (1) नेस्टेड लूप्स, (2) सशर्त रूप से, (3) नेस्टेड कार्य कर सकते हैं:

async function task(i) { // 3
  await timer(1000);
  console.log(`Task ${i} done!`);
}

async function main() {
  for(let i = 0; i < 100; i+= 10) {
    for(let j = 0; j < 10; j++) { // 1
      if(j % 2) { // 2
        await task(i + j);
      }
    }
  }
}
    
main();

function timer(ms) { return new Promise(res => setTimeout(res, ms)); }

एमडीएन पर संदर्भ

जबकि ES7 अब NodeJS और आधुनिक ब्राउज़रों द्वारा समर्थित है, आप शायद इसे BabelJS के साथ ट्रांसपाइल करना चाहते हैं ताकि यह हर जगह चलता रहे।

Comments

यह मेरे लिए ठीक काम करता है। मैं बस यह पूछना चाहता हूं कि अगर मैं लूप को तोड़ना चाहता हूं, तो मैं वेट का उपयोग करते समय कैसे कर सकता हूं?

— सचिन शाह

@ सचिन break;शायद?

— जोनास विल्म्स

इस समाधान के लिए धन्यवाद। सभी मौजूदा नियंत्रण संरचनाओं का उपयोग करना अच्छा है और निरंतरता का आविष्कार करने की आवश्यकता नहीं है।

— गस

यह अभी भी विभिन्न टाइमर बनाएगा और वे अनुक्रम के बजाय अलग-अलग समय पर हल करेंगे?

— डेविड येल

@ जोनासविल्म्स लगता है कि मैं पूरी तरह से 'रन स्निपेट' बटन याद कर रहा हूं: फेसपॉल:

— डेविड येल

Answer 5

एक और तरीका यह है कि टाइमआउट को समय से गुणा करें, लेकिन ध्यान दें कि यह नींद की तरह नहीं है । लूप के बाद कोड तुरंत निष्पादित किया जाएगा, केवल कॉलबैक फ़ंक्शन का निष्पादन स्थगित है।

for (var start = 1; start < 10; start++)
    setTimeout(function () { alert('hello');  }, 3000 * start);

पहला टाइमआउट सेट किया जाएगा 3000 * 1, दूसरा 3000 * 2और इतने पर।

Comments

यह इंगित करने योग्य है कि आप startइस पद्धति का उपयोग करके अपने फ़ंक्शन के अंदर मज़बूती से उपयोग नहीं कर सकते हैं ।

— DBS

खराब अभ्यास - अनावश्यक स्मृति आवंटन।

— अलेक्जेंडर ट्रैखिमेनोक

रचनात्मकता के लिए अपवोट, लेकिन यह बहुत बुरा है। :)

— सालिवन

यह एक बुरा अभ्यास क्यों है, और इसमें मेमोरी आवंटन के मुद्दे क्यों हैं? क्या इस जवाब से वही समस्याएं होती हैं? stackoverflow.com/a/36018502/1337392

— फ्लेम_फिनिक्स

@Flame_Phoenix यह बुरा अभ्यास है क्योंकि कार्यक्रम प्रत्येक लूप के लिए एक टाइमर रखेगा, सभी टाइमर एक ही समय में चलेंगे। इसलिए यदि 1000 पुनरावृत्तियां हैं, तो शुरुआत में एक ही समय में 1000 टाइमर चलेंगे।

— जोकिम

Answer 6

यह काम करेगा

for (var i = 0; i < 10; i++) {
  (function(i) {
    setTimeout(function() { console.log(i); }, 100 * i);
  })(i);
}

इस पहेली को आजमाएं: https://jsfiddle.net/wgdx8zqq/

Comments

यह सभी टाइमआउट कॉल को एक ही समय में ट्रिगर करता है हालांकि

— एडी

केवल एक चीज जो मैं कहता हूं, मैंने इस तरह से फटा है, इस्तेमाल किया है $.Deferredलेकिन इसे काम करने देने के लिए कुछ अलग परिदृश्य थे, अंगूठे आपको ..!

— आरिफमुस्तफा

Answer 7

मुझे लगता है कि आपको कुछ इस तरह की आवश्यकता है:

var TimedQueue = function(defaultDelay){
    this.queue = [];
    this.index = 0;
    this.defaultDelay = defaultDelay || 3000;
};

TimedQueue.prototype = {
    add: function(fn, delay){
        this.queue.push({
            fn: fn,
            delay: delay
        });
    },
    run: function(index){
        (index || index === 0) && (this.index = index);
        this.next();
    },
    next: function(){
        var self = this
        , i = this.index++
        , at = this.queue[i]
        , next = this.queue[this.index]
        if(!at) return;
        at.fn();
        next && setTimeout(function(){
            self.next();
        }, next.delay||this.defaultDelay);
    },
    reset: function(){
        this.index = 0;
    }
}

टेस्ट कोड:

var now = +new Date();

var x = new TimedQueue(2000);

x.add(function(){
    console.log('hey');
    console.log(+new Date() - now);
});
x.add(function(){
    console.log('ho');
    console.log(+new Date() - now);
}, 3000);
x.add(function(){
    console.log('bye');
    console.log(+new Date() - now);
});

x.run();

नोट: अलर्ट का उपयोग करते हुए अलर्ट स्टॉप जावास्क्रिप्ट निष्पादन को बंद करें। यह आपके द्वारा पूछे जाने से अधिक कोड हो सकता है, लेकिन यह एक मजबूत पुन: प्रयोज्य समाधान है।

Answer 8

मैं शायद उपयोग करूंगा setInteval। ऐशे ही,

var period = 1000; // ms
var endTime = 10000;  // ms
var counter = 0;
var sleepyAlert = setInterval(function(){
    alert('Hello');
    if(counter === endTime){
       clearInterval(sleepyAlert);
    }
    counter += period;
}, period);

Comments

सेटटाइमआउट से बेहतर है। यह Google और आप जानेंगे

— Airy

मैंने इसे थोड़ा सा गूगल किया और मुझे कुछ भी नहीं मिला, Why setInterval खराब है? क्या आप हमें एक लिंक दे सकते हैं? या एक उदाहरण? धन्यवाद

— मार्क्स

मुझे लगता है कि बिंदु यह था कि SetInterval()कुछ त्रुटि या ब्लॉक होने की स्थिति में भी 'थ्रेड्स' पैदा करता रहता है।

— मातेन उल्हाक

Answer 9

ईएस 6 (ईसीएमएस्क्रिप्ट 2015) में आप जनरेटर और अंतराल के साथ देरी से पुनरावृत्ति कर सकते हैं।

जनरेटर, ईसीएमएस्क्रिप्ट 6 की एक नई विशेषता, ऐसे कार्य हैं जिन्हें रोका जा सकता है और फिर से शुरू किया जा सकता है। GenFunc को कॉल करने से इसका निष्पादन नहीं होता है। इसके बजाय, यह एक तथाकथित जनरेटर ऑब्जेक्ट देता है जो हमें genFunc के निष्पादन को नियंत्रित करने देता है। genFunc () शुरू में अपने शरीर की शुरुआत में निलंबित हो जाता है। विधि genObj.next () अगली उपज तक genFunc के निष्पादन को जारी रखता है। (ईएस 6 की खोज)

कोड उदाहरण:

let arr = [1, 2, 3, 'b'];
let genObj = genFunc();

let val = genObj.next();
console.log(val.value);

let interval = setInterval(() => {
  val = genObj.next();
  
  if (val.done) {
    clearInterval(interval);
  } else {
    console.log(val.value);
  }
}, 1000);

function* genFunc() {
  for(let item of arr) {
    yield item;
  }
}

इसलिए यदि आप ईएस 6 का उपयोग कर रहे हैं, तो देरी के साथ लूप प्राप्त करने का सबसे सुंदर तरीका है (मेरी राय के लिए)।

Answer 10

आप RxJS अंतराल ऑपरेटर का उपयोग कर सकते हैं । अंतराल प्रत्येक x संख्या में सेकंड में पूर्णांक का उत्सर्जन करता है, और संख्या निर्दिष्ट करने के लिए इसे लेने की संख्या को निर्दिष्ट करना होता है

Rx.Observable
  .interval(1000)
  .take(10)
  .subscribe((x) => console.log(x))

<script src="https://cdnjs.cloudflare.com/ajax/libs/rxjs/4.1.0/rx.lite.min.js"></script>

Answer 11

बस मैंने सोचा कि मैं अपने दो सेंट यहाँ भी पोस्ट करूँगा। यह फ़ंक्शन विलंब के साथ पुनरावृत्त लूप चलाता है। इस jsfiddle देखें । फ़ंक्शन निम्नानुसार है:

function timeout(range, time, callback){
    var i = range[0];                
    callback(i);
    Loop();
    function Loop(){
        setTimeout(function(){
            i++;
            if (i<range[1]){
                callback(i);
                Loop();
            }
        }, time*1000)
    } 
}

उदाहरण के लिए:

//This function prints the loop number every second
timeout([0, 5], 1, function(i){
    console.log(i);
});

के बराबर होगा:

//This function prints the loop number instantly
for (var i = 0; i<5; i++){
    console.log(i);
}

Answer 12

मैं यह ब्लूबर्ड Promise.delayऔर पुनरावृत्ति के साथ करता हूं ।

function myLoop(i) {
  return Promise.delay(1000)
    .then(function() {
      if (i > 0) {
        alert('hello');
        return myLoop(i -= 1);
      }
    });
}

myLoop(3);

<script src="//cdnjs.cloudflare.com/ajax/libs/bluebird/2.9.4/bluebird.min.js"></script>

Answer 13

ES6 में आप निम्न कार्य कर सकते हैं:

 for (let i = 0; i <= 10; i++){       
     setTimeout(function () {   
        console.log(i);
     }, i*3000)
 }

ES5 में आप निम्न कार्य कर सकते हैं:

for (var i = 0; i <= 10; i++){
   (function(i) {          
     setTimeout(function () {   
        console.log(i);
     }, i*3000)
   })(i);  
 }

इसका कारण है, letआपको उन चरों की घोषणा करने की अनुमति देता है, जो ब्लॉक स्टेटमेंट के दायरे तक सीमित हैं, या जिस पर यह varकीवर्ड के विपरीत प्रयोग किया जाता है , जो वैश्विक स्तर पर एक चर को परिभाषित करता है, या स्थानीय रूप से ब्लॉक फ़ंक्शन की परवाह किए बिना एक पूरे फ़ंक्शन के लिए।

Answer 14

    var startIndex = 0;
    var data = [1, 2, 3];
    var timeout = 1000;

    function functionToRun(i, length) {
      alert(data[i]);
    }

    (function forWithDelay(i, length, fn, delay) {
      setTimeout(function() {
        fn(i, length);
        i++;
        if (i < length) {
          forWithDelay(i, length, fn, delay);
        }
      }, delay);
    })(startIndex, data.length, functionToRun, timeout);

फ़ंक्शन को अधिक पुन: प्रयोज्य बनाने के लिए मापदंडों में निकाले गए चर के साथ डैनियल वैसलो के उत्तर का एक संशोधित संस्करण:

पहले कुछ आवश्यक चर को परिभाषित करते हैं:

var startIndex = 0;
var data = [1, 2, 3];
var timeout = 3000;

आगे आपको उस फ़ंक्शन को परिभाषित करना चाहिए जिसे आप चलाना चाहते हैं। यदि आपको इसकी आवश्यकता है, तो मैं पास हो जाएगा, लूप का वर्तमान सूचकांक और लूप की लंबाई,

function functionToRun(i, length) {
    alert(data[i]);
}

स्व-निष्पादित संस्करण

(function forWithDelay(i, length, fn, delay) {
   setTimeout(function () {
      fn(i, length);
      i++;
      if (i < length) {
         forWithDelay(i, length, fn, delay); 
      }
  }, delay);
})(startIndex, data.length, functionToRun, timeout);

कार्यात्मक संस्करण

function forWithDelay(i, length, fn, delay) {
   setTimeout(function () {
      fn(i, length);
      i++;
      if (i < length) {
         forWithDelay(i, length, fn, delay); 
      }
  }, delay);
}

forWithDelay(startIndex, data.length, functionToRun, timeout); // Lets run it

Comments

अच्छा है और मैं एक वैश्विक चर के बिना फ़ंक्शन को डेटा कैसे पास कर सकता हूं

— सुंदर प्रभू

Answer 15

   let counter =1;
   for(let item in items) {
        counter++;
        setTimeout(()=>{
          //your code
        },counter*5000); //5Sec delay between each iteration
    }

Answer 16

आप इसे करते हैं:

console.log('hi')
let start = 1
setTimeout(function(){
  let interval = setInterval(function(){
    if(start == 10) clearInterval(interval)
    start++
    console.log('hello')
  }, 3000)
}, 3000)

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>

Comments

अलर्ट के बजाय बेहतर उपयोग कंसोल लॉग, आधे मिनट के लिए अलर्ट बंद करने के लिए बहुत मज़ेदार नहीं था;)

— हेंड्री

हाँ। समझा! लेकिन अनुरोध सतर्क है ... huz

— गुयेन बा

क्यों आयात करें jQuery?

— इलायस सोरेस

क्षमा करें ... यह अनावश्यक .. हे। मैं पोस्ट सामग्री नहीं जानता ... यह पहली बार।

— गुयेन बा दानह - FAIC HN

Answer 17

/* 
  Use Recursive  and setTimeout 
  call below function will run loop loopFunctionNeedCheck until 
  conditionCheckAfterRunFn = true, if conditionCheckAfterRunFn == false : delay 
  reRunAfterMs miliseconds and continue loop
  tested code, thanks
*/

function functionRepeatUntilConditionTrue(reRunAfterMs, conditionCheckAfterRunFn,
 loopFunctionNeedCheck) {
    loopFunctionNeedCheck();
    var result = conditionCheckAfterRunFn();
    //check after run
    if (!result) {
        setTimeout(function () {
            functionRepeatUntilConditionTrue(reRunAfterMs, conditionCheckAfterRunFn, loopFunctionNeedCheck)
        }, reRunAfterMs);
    }
    else  console.log("completed, thanks");    
            //if you need call a function after completed add code call callback in here
}

//passing-parameters-to-a-callback-function
// From Prototype.js 
if (!Function.prototype.bind) { // check if native implementation available
    Function.prototype.bind = function () {
        var fn = this, args = Array.prototype.slice.call(arguments),
            object = args.shift();
        return function () {
            return fn.apply(object,
              args.concat(Array.prototype.slice.call(arguments)));
        };
    };
}

//test code: 
var result = 0; 
console.log("---> init result is " + result);
var functionNeedRun = function (step) {           
   result+=step;    
       console.log("current result is " + result);  
}
var checkResultFunction = function () {
    return result==100;
}  

//call this function will run loop functionNeedRun and delay 500 miliseconds until result=100    
functionRepeatUntilConditionTrue(500, checkResultFunction , functionNeedRun.bind(null, 5));

//result log from console:
/*
---> init result is 0
current result is 5
undefined
current result is 10
current result is 15
current result is 20
current result is 25
current result is 30
current result is 35
current result is 40
current result is 45
current result is 50
current result is 55
current result is 60
current result is 65
current result is 70
current result is 75
current result is 80
current result is 85
current result is 90
current result is 95
current result is 100
completed, thanks
*/

Comments

आपके फ़ंक्शन नाम भयावह हैं, यही मुख्य कारण है कि इस कोड को पढ़ना इतना कठिन है।

— मार्क वाल्टर

Answer 18

यहां बताया गया है कि मैंने एक निश्चित समय पर टूटने वाली देरी के साथ एक अनंत लूप बनाया:

  // Now continuously check the app status until it's completed, 
  // failed or times out. The isFinished() will throw exception if
  // there is a failure.
  while (true) {
    let status = await this.api.getStatus(appId);
    if (isFinished(status)) {
      break;
    } else {
      // Delay before running the next loop iteration:
      await new Promise(resolve => setTimeout(resolve, 3000));
    }
  }

यहां कुंजी एक नया प्रॉमिस बनाना है जो टाइमआउट द्वारा हल होता है, और इसके संकल्प की प्रतीक्षा करता है।

जाहिर है कि आपको इसके लिए async / प्रतीक्षा समर्थन की आवश्यकता है। नोड 8 में काम करता है।

Answer 19

आम उपयोग के लिए "सामान्य छोरों को भूल जाओ" और "सेटइंटरवल" के इस संयोजन का उपयोग करें, इसमें "setTimeOut" s शामिल है: इस तरह (मेरे वास्तविक कार्यों से)।

        function iAsk(lvl){
            var i=0;
            var intr =setInterval(function(){ // start the loop 
                i++; // increment it
                if(i>lvl){ // check if the end round reached.
                    clearInterval(intr);
                    return;
                }
                setTimeout(function(){
                    $(".imag").prop("src",pPng); // do first bla bla bla after 50 millisecond
                },50);
                setTimeout(function(){
                     // do another bla bla bla after 100 millisecond.
                    seq[i-1]=(Math.ceil(Math.random()*4)).toString();
                    $("#hh").after('<br>'+i + ' : rand= '+(Math.ceil(Math.random()*4)).toString()+' > '+seq[i-1]);
                    $("#d"+seq[i-1]).prop("src",pGif);
                    var d =document.getElementById('aud');
                    d.play();                   
                },100);
                setTimeout(function(){
                    // keep adding bla bla bla till you done :)
                    $("#d"+seq[i-1]).prop("src",pPng);
                },900);
            },1000); // loop waiting time must be >= 900 (biggest timeOut for inside actions)
        }

पुनश्च: समझें कि (setTimeOut) का वास्तविक व्यवहार: वे सभी एक ही समय में शुरू होंगे "तीन ब्ला ब्ला ब्ला एक ही पल में नीचे गिनना शुरू कर देंगे" इसलिए निष्पादन को व्यवस्थित करने के लिए एक अलग समयबाह्य करें।

पुनश्च 2: टाइमिंग लूप के लिए उदाहरण है, लेकिन एक प्रतिक्रिया लूप के लिए आप घटनाओं का उपयोग कर सकते हैं, async प्रतीक्षा का वादा कर सकते हैं ..

Answer 20

<!DOCTYPE html>
<html>
<body>

<button onclick="myFunction()">Try it</button>

<p id="demo"></p>

<script>
function myFunction() {
    for(var i=0; i<5; i++) {
    	var sno = i+1;
       	(function myLoop (i) {          
             setTimeout(function () {   
             	alert(i); // Do your function here 
             }, 1000*i);
        })(sno);
    }
}
</script>

</body>
</html>

Comments

कृपया हमेशा अपने कोड स्निपेट का कम से कम संक्षिप्त विवरण प्रदान करें, कम से कम दूसरों के लिए सुनिश्चित करें कि आप प्रश्न को संबोधित करते हैं।

— हेक्सफ़ायर

कोड केवल उत्तर को प्रोत्साहित करता है क्योंकि वे भविष्य के पाठकों के लिए अधिक जानकारी प्रदान नहीं करते हैं, कृपया जो कुछ आपने लिखा है, उसके बारे में कुछ स्पष्टीकरण प्रदान करें

— व्हाट्सएप ग्रुप

Answer 21

मेरी जानकारी के लिए setTimeoutफ़ंक्शन को एसिंक्रोनसली कहा जाता है। आप जो भी कर सकते हैं वह पूरे लूप को एक async फ़ंक्शन के भीतर लपेटता है और प्रतीक्षा करता Promiseहै जिसमें दिखाया गया सेटटाइमआउट होता है:

var looper = async function () {
  for (var start = 1; start < 10; start++) {
    await new Promise(function (resolve, reject) {
      setTimeout(function () {
        console.log("iteration: " + start.toString());
        resolve(true);
      }, 1000);
    });
  }
  return true;
}

और फिर आप इसे ऐसे चलाते हैं:

looper().then(function(){
  console.log("DONE!")
});

अतुल्यकालिक प्रोग्रामिंग की अच्छी समझ पाने के लिए कृपया कुछ समय लें।

Answer 22

बस यह कोशिश करो

 var arr = ['A','B','C'];
 (function customLoop (arr, i) {
    setTimeout(function () {
    // Do here what you want to do.......
    console.log(arr[i]);
    if (--i) {                
      customLoop(arr, i); 
    }
  }, 2000);
})(arr, arr.length);

परिणाम

A // after 2s
B // after 2s
C // after 2s

Answer 23

यहाँ एक फ़ंक्शन है जिसका उपयोग मैं एक सरणी पर लूपिंग के लिए करता हूं:

function loopOnArrayWithDelay(theArray, delayAmount, i, theFunction, onComplete){

    if (i < theArray.length && typeof delayAmount == 'number'){

        console.log("i "+i);

        theFunction(theArray[i], i);

        setTimeout(function(){

            loopOnArrayWithDelay(theArray, delayAmount, (i+1), theFunction, onComplete)}, delayAmount);
    }else{

        onComplete(i);
    }
}

आप इसे इस तरह उपयोग करते हैं:

loopOnArrayWithDelay(YourArray, 1000, 0, function(e, i){
    //Do something with item
}, function(i){
    //Do something once loop has completed
}

Answer 24

यह स्क्रिप्ट ज्यादातर चीजों के लिए काम करती है

function timer(start) {
    setTimeout(function () { //The timer
        alert('hello');
    }, start*3000); //needs the "start*" or else all the timers will run at 3000ms
}

for(var start = 1; start < 10; start++) {
    timer(start);
}

Answer 25

इसे इस्तेमाल करे...

var icount=0;
for (let i in items) {
   icount=icount+1000;
   new beginCount(items[i],icount);
}

function beginCount(item,icount){
  setTimeout(function () {

   new actualFunction(item,icount);

 }, icount);
}

function actualFunction(item,icount){
  //...runs ever 1 second
 console.log(icount);
}

Answer 26

जब तक लूप चल रहा है तब तक हर दो सेकंड में पाठ का एक टुकड़ा दिखाने का सरल कार्यान्वयन।

for (var i = 0; i < foo.length; i++) {
   setInterval(function(){ 
     console.log("I will appear every 2 seconds"); 
   }, 2000);
  break;
};

Answer 27

इसे इस्तेमाल करे

//the code will execute in 1 3 5 7 9 seconds later
function exec(){
  for(var i=0;i<5;i++){
   setTimeout(function(){
     console.log(new Date());   //It's you code
   },(i+i+1)*1000);
  }
}