दिलचस्प पोस्ट
Z- इंडेक्स स्टैकिंग ऑर्डर को समझना HTTP हेडर लाइन ब्रेक शैली PHP में एक अनिवार्य समारोह क्या है? कैसे पता लगाया जाए कि क्या कोई स्क्रिप्ट स्रोत है? पृष्ठांकन पृष्ठ पर कैसे ROWNUM काम करता है? PHP के साथ काम कर रहे जावा एचटीटीपी क्लाइंट लाइब्रेरी का उपयोग कर एक फाइल कैसे अपलोड करें क्या stdout लाइन बफ़र, बंडल या डिफ़ॉल्ट रूप से अनिश्चित है? जावा के लिए सबसे अच्छा नकली ढांचे क्या है? जावास्क्रिप्ट में सटीक वित्तीय गणना गोच क्या हैं? बैकस्लैश को पायथन के साथ कैसे मुद्रित करें? सीएसएस का उपयोग कर खाली इनपुट बॉक्स का मिलान करना मैं अपने जार फ़ाइल के अंदर से एक संसाधन "फ़ोल्डर" कैसे प्राप्त करूं? java runtime.getruntime () कमांड लाइन प्रोग्राम निष्पादित करने से आउटपुट प्राप्त कर रहा है मैथलेट कोड को पायथन में परिवर्तित करने के लिए एक उपकरण फेसबुक एपीआई: प्रशंसक बनें / लोग जो एक पृष्ठ पसंद करते हैं

जावास्क्रिप्ट: विराम सेटटिमेउट ();

अगर मेरे पास एक सक्रिय समयबाह्य चल रहा है जो var t = setTimeout("dosomething()", 5000) माध्यम से सेट किया गया था,

क्या किसी भी तरह से इसे रोकना और फिर से शुरू करना है?


क्या वर्तमान समय समाप्त होने पर शेष समय प्राप्त करने का कोई तरीका है?
या मुझे एक वेरिएबल में करना पड़ता है, जब समय समाप्त हो जाता है, वर्तमान समय को स्टोर करते हैं, तो हम रोकते हैं, अब और फिर के बीच में अंतर पा सकते हैं?

वेब के समाधान से एकत्रित समाधान "जावास्क्रिप्ट: विराम सेटटिमेउट ();"

आप इस तरह window.setTimeout कर सकते हैं, जो मुझे लगता है कि आप इस प्रश्न में क्या सुझाव दे रहे थे।

 function Timer(callback, delay) { var timerId, start, remaining = delay; this.pause = function() { window.clearTimeout(timerId); remaining -= new Date() - start; }; this.resume = function() { start = new Date(); window.clearTimeout(timerId); timerId = window.setTimeout(callback, remaining); }; this.resume(); } var timer = new Timer(function() { alert("Done!"); }, 1000); timer.pause(); // Do some stuff... timer.resume(); 

इस तरह से कुछ को चाल करना चाहिए।

 function Timer(fn, countdown) { var ident, complete = false; function _time_diff(date1, date2) { return date2 ? date2 - date1 : new Date().getTime() - date1; } function cancel() { clearTimeout(ident); } function pause() { clearTimeout(ident); total_time_run = _time_diff(start_time); complete = total_time_run >= countdown; } function resume() { ident = complete ? -1 : setTimeout(fn, countdown - total_time_run); } var start_time = new Date().getTime(); ident = setTimeout(fn, countdown); return { cancel: cancel, pause: pause, resume: resume }; } 

नहीं। आपको इसे रद्द करना होगा ( clearTimeout ), उस समय को मापना चाहिए जब से आप इसे शुरू करेंगे और इसे नए समय के साथ पुनः आरंभ करेंगे।

setTimeout के संदर्भ में "रोकें" और "फिर से शुरू" वास्तव में ज्यादा मायने नहीं रखता है, जो एक बंद बात है क्या आप सेट setInterval मतलब है? यदि हां, तो नहीं, आप इसे रोक नहीं सकते, आप केवल इसे रद्द कर सकते हैं ( clearInterval ) और फिर इसे फिर से शेड्यूल कर सकते हैं। विवरण के टाइमर अनुभाग में इन सभी का विवरण।

 // Setting var t = setInterval(doSomething, 1000); // Pausing (which is really stopping) clearInterval(t); t = 0; // Resuming (which is really just setting again) t = setInterval(doSomething, 1000); 

टिम डाउस के उत्तर का थोड़ा संशोधित संस्करण। हालांकि, चूंकि टिम ने मेरे संपादन को वापस लहराया, मुझे स्वयं को इसका उत्तर देना होगा मेरा समाधान तीसरा (3, 4, 5 …) पैरामीटर के रूप में और टाइमर को खाली करने के लिए अतिरिक्त arguments का उपयोग करना संभव बनाता है:

 function Timer(callback, delay) { var args = arguments, self = this, timer, start; this.clear = function () { clearTimeout(timer); }; this.pause = function () { this.clear(); delay -= new Date() - start; }; this.resume = function () { start = new Date(); timer = setTimeout(function () { callback.apply(self, Array.prototype.slice.call(args, 2, args.length)); }, delay); }; this.resume(); } 

जैसा टिम उल्लेख किया गया है, अतिरिक्त पैरामीटर IE lt 9 में उपलब्ध नहीं हैं, हालांकि मैंने थोड़ा काम किया है ताकि यह oldIE में भी काम करे।

उपयोग: new Timer(Function, Number, arg1, arg2, arg3...)

 function callback(foo, bar) { console.log(foo); // "foo" console.log(bar); // "bar" } var timer = new Timer(callback, 1000, "foo", "bar"); timer.pause(); document.onclick = timer.resume; 

समय समाप्त करने के लिए एक समाधान खोजने के लिए पर्याप्त आसान था, लेकिन अंतराल थोड़ी जटिल था

मैं इस मुद्दे को हल करने के लिए निम्न दो वर्गों के साथ आया हूं:

 function PauseableTimeout(func, delay){ this.func = func; var _now = new Date().getTime(); this.triggerTime = _now + delay; this.t = window.setTimeout(this.func,delay); this.paused_timeLeft = 0; this.getTimeLeft = function(){ var now = new Date(); return this.triggerTime - now; } this.pause = function(){ this.paused_timeLeft = this.getTimeLeft(); window.clearTimeout(this.t); this.t = null; } this.resume = function(){ if (this.t == null){ this.t = window.setTimeout(this.func, this.paused_timeLeft); } } this.clearTimeout = function(){ window.clearTimeout(this.t);} } function PauseableInterval(func, delay){ this.func = func; this.delay = delay; this.triggerSetAt = new Date().getTime(); this.triggerTime = this.triggerSetAt + this.delay; this.i = window.setInterval(this.func, this.delay); this.t_restart = null; this.paused_timeLeft = 0; this.getTimeLeft = function(){ var now = new Date(); return this.delay - ((now - this.triggerSetAt) % this.delay); } this.pause = function(){ this.paused_timeLeft = this.getTimeLeft(); window.clearInterval(this.i); this.i = null; } this.restart = function(sender){ sender.i = window.setInterval(sender.func, sender.delay); } this.resume = function(){ if (this.i == null){ this.i = window.setTimeout(this.restart, this.paused_timeLeft, this); } } this.clearInterval = function(){ window.clearInterval(this.i);} } 

इन्हें इस प्रकार लागू किया जा सकता है:

 var pt_hey = new PauseableTimeout(function(){ alert("hello"); }, 2000); window.setTimeout(function(){ pt_hey.pause(); }, 1000); window.setTimeout("pt_hey.start()", 2000); 

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

अब ट्रिकल अंतराल के लिए

 var pi_hey = new PauseableInterval(function(){ console.log("hello world"); }, 2000); window.setTimeout("pi_hey.pause()", 5000); window.setTimeout("pi_hey.resume()", 6000); 

इस उदाहरण को दो-दो सेकंड कंसोल में "हैलो वर्ल्ड" लिखने के लिए एक विरामपूर्ण अंतराल (pi_hey) सेट करता है एक टाइमआउट पांच सेकंड के बाद pi_hey को रोकता है। छह घंटे के बाद एक और टाइमआउट फिर से शुरू हो जाता है। तो pi_hey दो बार ट्रिगर करेगा, एक सेकंड के लिए चलाएगा, एक सेकंड के लिए विराम, एक सेकंड के लिए चलाएगा, और फिर हर 2 सेकंड ट्रिगर जारी रखें।

अन्य कार्य

  • स्पष्टटाइमआउट () और साफ़ अंतराल ()

    pt_hey.clearTimeout(); और pi_hey.clearInterval(); टाइमआउट और अंतराल को साफ करने का एक आसान तरीका के रूप में कार्य करें।

  • getTimeLeft ()

    pt_hey.getTimeLeft(); और pi_hey.getTimeLeft(); अगले ट्रिगर आने तक कितने मिलिसेकंड वापस आ जाएंगे।

प्रगति बार दिखाने के लिए मुझे बीत चुके और शेष समय की गणना करने की आवश्यकता है स्वीकार किए गए उत्तर का उपयोग करना आसान नहीं था। इस कार्य के लिए 'setInterval' 'setTimeout' से बेहतर है इसलिए, मैंने इस टाइमर वर्ग को बनाया है कि आप किसी भी प्रोजेक्ट में उपयोग कर सकते हैं।

https://jsfiddle.net/ashraffayad/t0mmv853/

 'use strict'; //Constructor var Timer = function(cb, delay) { this.cb = cb; this.delay = delay; this.elapsed = 0; this.remaining = this.delay - self.elapsed; }; console.log(Timer); Timer.prototype = function() { var _start = function(x, y) { var self = this; if (self.elapsed < self.delay) { clearInterval(self.interval); self.interval = setInterval(function() { self.elapsed += 50; self.remaining = self.delay - self.elapsed; console.log('elapsed: ' + self.elapsed, 'remaining: ' + self.remaining, 'delay: ' + self.delay); if (self.elapsed >= self.delay) { clearInterval(self.interval); self.cb(); } }, 50); } }, _pause = function() { var self = this; clearInterval(self.interval); }, _restart = function() { var self = this; self.elapsed = 0; console.log(self); clearInterval(self.interval); self.start(); }; //public member definitions return { start: _start, pause: _pause, restart: _restart }; }(); // - - - - - - - - how to use this class var restartBtn = document.getElementById('restart'); var pauseBtn = document.getElementById('pause'); var startBtn = document.getElementById('start'); var timer = new Timer(function() { console.log('Done!'); }, 2000); restartBtn.addEventListener('click', function(e) { timer.restart(); }); pauseBtn.addEventListener('click', function(e) { timer.pause(); }); startBtn.addEventListener('click', function(e) { timer.start(); }); 

मुझे नहीं लगता कि आपको स्पष्ट समय के मुकाबले बेहतर कुछ मिलेगा। वैसे भी, आप बाद में एक समयबाह्य शेड्यूल कर सकते हैं, बजाय इसे 'फिर से शुरू' कर सकते हैं

आप इसे घटनाओं के साथ भी लागू कर सकते हैं

समय के अंतर की गणना करने के बजाय, आप 'टिक' घटना को सुनना बंद कर देते हैं और पृष्ठभूमि में चलते रहते हैं:

 var Slideshow = { _create: function(){ this.timer = window.setInterval(function(){ $(window).trigger('timer:tick'); }, 8000); }, play: function(){ $(window).bind('timer:tick', function(){ // stuff }); }, pause: function(){ $(window).unbind('timer:tick'); } }; 

अगर आप किसी भी तरह jquery का उपयोग कर रहे हैं, तो $ .doTimeout प्लगइन देखें। यह बात setTimeout पर एक बहुत बड़ा सुधार है, जिसमें आप अपने टाइम-आउट का ट्रैक रखने के लिए एक एकल स्ट्रिंग आईडी को ट्रैक करते हैं, जो आप निर्दिष्ट करते हैं और जो हर बार जब आप इसे सेट नहीं करते हैं, और आसान रद्द करना, पोलिंग लूप और डीब्यूनिंग कार्यान्वित करते हैं, और अधिक। मेरी सर्वाधिक उपयोग की गई jquery plugins में से एक

दुर्भाग्य से, यह बॉक्स के बाहर विराम / पुनरारंभ का समर्थन नहीं करता। इसके लिए, आपको $ .doTimeout को लपेटो या विस्तारित करने की आवश्यकता होगी, संभवत: स्वीकार किए गए उत्तर के लिए।

स्लाइडशो जैसी सुविधा के लिए setTimeout () को रोकने के लिए मुझे सक्षम होना चाहिए

यहाँ एक व्यावहारिक टाइमर का अपना स्वयं का कार्यान्वयन है I यह टिम डाउन के जवाब पर टिप्पणियों को एकीकृत करता है, जैसे बेहतर विराम (कर्नल की टिप्पणी) और प्रोटोटाइप का एक रूप (उमूर गदिक की टिप्पणी।)

 function Timer( callback, delay ) { /** Get access to this object by value **/ var self = this; /********************* PROPERTIES *********************/ this.delay = delay; this.callback = callback; this.starttime;// = ; this.timerID = null; /********************* METHODS *********************/ /** * Pause */ this.pause = function() { /** If the timer has already been paused, return **/ if ( self.timerID == null ) { console.log( 'Timer has been paused already.' ); return; } /** Pause the timer **/ window.clearTimeout( self.timerID ); self.timerID = null; // this is how we keep track of the timer having beem cleared /** Calculate the new delay for when we'll resume **/ self.delay = self.starttime + self.delay - new Date().getTime(); console.log( 'Paused the timer. Time left:', self.delay ); } /** * Resume */ this.resume = function() { self.starttime = new Date().getTime(); self.timerID = window.setTimeout( self.callback, self.delay ); console.log( 'Resuming the timer. Time left:', self.delay ); } /********************* CONSTRUCTOR METHOD *********************/ /** * Private constructor * Not a language construct. * Mind var to keep the function private and () to execute it right away. */ var __construct = function() { self.starttime = new Date().getTime(); self.timerID = window.setTimeout( self.callback, self.delay ) }(); /* END __construct */ } /* END Timer */ 

उदाहरण:

 var timer = new Timer( function(){ console.log( 'hey! this is a timer!' ); }, 10000 ); timer.pause(); 

कोड का परीक्षण करने के लिए, timer.resume() और timer.pause() उपयोग करें timer.resume() कुछ बार timer.pause() और जांच करें कि कितना समय बचा है। (सुनिश्चित करें कि आपका कंसोल खुला है।)

timerID = setTimeout( mycallback, 1000) () के स्थान पर इस ऑब्जेक्ट का उपयोग timer = new Timer( mycallback, 1000 ) timerID = setTimeout( mycallback, 1000) timer = new Timer( mycallback, 1000 ) । तब timer.pause() और timer.resume() लिए उपलब्ध हैं।

आप स्पष्ट टाइमआउट () में देख सकते हैं

या वैश्विक वैरिएबल के आधार पर विराम जो एक निश्चित स्थिति को मारा जाता है जब सेट हो जाता है। एक बटन की तरह दबाया जाता है

  <button onclick="myBool = true" > pauseTimeout </button> <script> var myBool = false; var t = setTimeout(function() {if (!mybool) {dosomething()}}, 5000); </script> 

/ पुनर्जीवित

कक्षा-वाई वाक्यविन्यास चीनी का उपयोग कर ES6 संस्करण 💋

(थोड़ा-संशोधित: जोड़ा गया प्रारंभ ())

 class Timer { constructor(callback, delay) { this.callback = callback this.remainingTime = delay this.startTime this.timerId } pause() { clearTimeout(this.timerId) this.remainingTime -= new Date() - this.startTime } resume() { this.startTime = new Date() clearTimeout(this.timerId) this.timerId = setTimeout(this.callback, this.remainingTime) } start() { this.timerId = setTimeout(this.callback, this.remainingTime) } } // supporting code const pauseButton = document.getElementById('timer-pause') const resumeButton = document.getElementById('timer-resume') const startButton = document.getElementById('timer-start') const timer = new Timer(() => { console.log('called'); document.getElementById('change-me').classList.add('wow') }, 3000) pauseButton.addEventListener('click', timer.pause.bind(timer)) resumeButton.addEventListener('click', timer.resume.bind(timer)) startButton.addEventListener('click', timer.start.bind(timer)) 
 <!doctype html> <html> <head> <title>Traditional HTML Document. ZZz...</title> <style type="text/css"> .wow { color: blue; font-family: Tahoma, sans-serif; font-size: 1em; } </style> </head> <body> <h1>DOM &amp; JavaScript</h1> <div id="change-me">I'm going to repaint my life, wait and see.</div> <button id="timer-start">Start!</button> <button id="timer-pause">Pause!</button> <button id="timer-resume">Resume!</button> </body> </html> 

अगर आपके पास छिपाने के लिए कई डिवाइसेस हैं, तो आप एक सेट setInterval और कई चक्रों का इस्तेमाल कर सकते हैं जैसे:

 <div id="div1">1</div><div id="div2">2</div> <div id="div3">3</div><div id="div4">4</div> <script> function hideDiv(elm){ var interval, unit = 1000, cycle = 5, hide = function(){ interval = setInterval(function(){ if(--cycle === 0){ elm.style.display = 'none'; clearInterval(interval); } elm.setAttribute('data-cycle', cycle); elm.innerHTML += '*'; }, unit); }; elm.onmouseover = function(){ clearInterval(interval); }; elm.onmouseout = function(){ hide(); }; hide(); } function hideDivs(ids){ var id; while(id = ids.pop()){ hideDiv(document.getElementById(id)); } } hideDivs(['div1','div2','div3','div4']); </script>