Modifica dell’intervallo di SetInterval mentre è in esecuzione

Ho scritto una funzione javascript che usa setInterval per manipolare una stringa ogni decimo di secondo per un certo numero di iterazioni.

function timer() { var section = document.getElementById('txt').value; var len = section.length; var rands = new Array(); for (i=0; i<len; i++) { rands.push(Math.floor(Math.random()*len)); }; var counter = 0 var interval = setInterval(function() { var letters = section.split(''); for (j=0; j < len; j++) { if (counter  rands.max()) { clearInterval(interval); } }, 100); }; 

Invece di avere l’intervallo impostato su un numero specifico, vorrei aggiornarlo ogni volta che viene eseguito, in base a un contatore. Quindi, invece di:

 var interval = setInterval(function() { ... }, 100); 

Sarebbe qualcosa di simile:

 var interval = setInterval(function() { ... }, 10*counter); 

Sfortunatamente, questo non ha funzionato. Sembrava che “10 * counter” fosse uguale a 0.

Quindi, come posso regolare l’intervallo ogni volta che viene eseguita la funzione anonima?

Utilizzare invece setTimeout() . Il callback sarebbe quindi responsabile per il successivo timeout, a quel punto è ansible aumentare o altrimenti modificare i tempi.

MODIFICARE

Ecco una funzione generica che è ansible utilizzare per applicare un timeout “decelerazione” per QUALSIASI chiamata di funzione.

 function setDeceleratingTimeout(callback, factor, times) { var internalCallback = function(tick, counter) { return function() { if (--tick >= 0) { window.setTimeout(internalCallback, ++counter * factor); callback(); } } }(times, 0); window.setTimeout(internalCallback, factor); }; // console.log() requires firebug setDeceleratingTimeout(function(){ console.log('hi'); }, 10, 10); setDeceleratingTimeout(function(){ console.log('bye'); }, 100, 10); 

Potresti usare una funzione anonima:

 var counter = 10; var myFunction = function(){ clearInterval(interval); counter *= 10; interval = setInterval(myFunction, counter); } var interval = setInterval(myFunction, counter); 

AGGIORNAMENTO: Come suggerito da A. Wolff, utilizzare setTimeout per evitare la necessità di clearInterval .

 var counter = 10; var myFunction = function() { counter *= 10; setTimeout(myFunction, counter); } setTimeout(myFunction, counter); 

Mi piace questa domanda: mi ha ispirato un piccolo object temporizzatore:

 window.setVariableInterval = function(callbackFunc, timing) { var variableInterval = { interval: timing, callback: callbackFunc, stopped: false, runLoop: function() { if (variableInterval.stopped) return; var result = variableInterval.callback.call(variableInterval); if (typeof result == 'number') { if (result === 0) return; variableInterval.interval = result; } variableInterval.loop(); }, stop: function() { this.stopped = true; window.clearTimeout(this.timeout); }, start: function() { this.stopped = false; return this.loop(); }, loop: function() { this.timeout = window.setTimeout(this.runLoop, this.interval); return this; } }; return variableInterval.start(); }; 

Esempio di utilizzo

 var vi = setVariableInterval(function() { // this is the variableInterval - so we can change/get the interval here: var interval = this.interval; // print it for the hell of it console.log(interval); // we can stop ourselves. if (interval>4000) this.stop(); // we could return a new interval after doing something return interval + 100; }, 100); // we can change the interval down here too setTimeout(function() { vi.interval = 3500; }, 1000); // or tell it to start back up in a minute setTimeout(function() { vi.interval = 100; vi.start(); }, 60000); 

Ho avuto la stessa domanda del poster originale, ho fatto questa soluzione. Non sei sicuro di quanto sia efficace questo ….

 interval = 5000; // initial condition var run = setInterval(request , interval); // start setInterval as "run" function request() { console.log(interval); // firebug or chrome log clearInterval(run); // stop the setInterval() // dynamically change the run interval if(interval>200 ){ interval = interval*.8; }else{ interval = interval*1.2; } run = setInterval(request, interval); // start the setInterval() } 

Questo è il mio modo di farlo, uso setTimeout:

 var timer = { running: false, iv: 5000, timeout: false, cb : function(){}, start : function(cb,iv){ var elm = this; clearInterval(this.timeout); this.running = true; if(cb) this.cb = cb; if(iv) this.iv = iv; this.timeout = setTimeout(function(){elm.execute(elm)}, this.iv); }, execute : function(e){ if(!e.running) return false; e.cb(); e.start(); }, stop : function(){ this.running = false; }, set_interval : function(iv){ clearInterval(this.timeout); this.start(false, iv); } }; 

Uso:

 timer.start(function(){ console.debug('go'); }, 2000); timer.set_interval(500); timer.stop(); 

Un modo molto più semplice sarebbe avere un’istruzione if nella funzione aggiornata e un controllo per eseguire il comando a intervalli di tempo regolari. Nell’esempio seguente, intrv un avviso ogni 2 secondi e l’intervallo ( intrv ) può essere modificato dynamicmente …

 var i=1; var intrv=2; // < < control this variable var refreshId = setInterval(function() { if(!(i%intrv)) { alert('run!'); } i++; }, 1000); 

Risposta semplice è che non è ansible aggiornare un intervallo di timer già creato . (Esistono solo due funzioni setInterval/setTimer e clearInterval/clearTimer , quindi avendo un timerId puoi solo distriggersrlo.) Ma puoi fare qualche soluzione. Dai un’occhiata a questo repository Github .

Questo può essere avviato come vuoi tu. timeout è il metodo che ho usato per tenerlo in cima all’ora.

Ho avuto bisogno di ogni ora per iniziare un blocco di codice all’ora. Quindi questo dovrebbe iniziare all’avvio del server ed eseguire l’intervallo ogni ora. Fondamentalmente la corsa iniziale è iniziare l’intervallo entro lo stesso minuto. Quindi in un secondo da init, esegui immediatamente e poi ogni 5 secondi.

 var interval = 1000; var timing =function(){ var timer = setInterval(function(){ console.log(interval); if(interval == 1000){ /*interval you dont want anymore or increment/decrement */ interval = 3600000; /* Increment you do want for timer */ clearInterval(timer); timing(); } },interval); } timing(); 

In alternativa, se volevi che succedesse qualcosa all’avvio e poi per sempre a un intervallo specifico, puoi chiamarlo contemporaneamente al setInterval. Per esempio:

 var this = function(){ //do } setInterval(function(){ this() },3600000) this() 

Qui abbiamo questa corsa la prima volta e poi ogni ora.

Non potevo sincronizzare e cambiare la velocità del mio setIntervals e stavo per pubblicare una domanda. Ma penso di aver trovato un modo. Dovrebbe essere sicuramente migliorato perché sono un principiante. Quindi, leggerei volentieri i vostri commenti / osservazioni su questo.

  
0
2nd counter is stopped

Se vuoi che i contatori inizino ad aumentare una volta caricata la pagina, metti counter1() e counter2() in foo() prima che countingSpeed venga chiamato. Altrimenti, occorrono millisecondi di speed prima dell’esecuzione. EDIT: risposta più breve.

 var counter = 15; var interval = setTimeout(function(){ // your interval code here window.counter = dynamicValue; interval(); }, counter); 

Sono un principiante in javascript e non ho trovato alcun aiuto nelle risposte precedenti (ma molte buone idee).
Questo pezzo di codice di seguito accelera (accelerazione> 1) o decelera (accelerazione <1). Spero che possa aiutare alcune persone:

 function accelerate(yourfunction, timer, refresh, acceleration) { var new_timer = timer / acceleration; var refresh_init = refresh;//save this user defined value if (refresh < new_timer ){//avoid reseting the interval before it has produced anything. refresh = new_timer + 1 ; }; var lastInter = setInterval(yourfunction, new_timer); console.log("timer:", new_timer); function stopLastInter() { clearInterval(lastInter); accelerate(yourfunction, new_timer, refresh_init, acceleration); console.log("refresh:", refresh); }; setTimeout(stopLastInter, refresh); } 

Con :

  • timer : il valore iniziale setInterval in ms (crescente o decrescente)
  • refresh : il tempo prima che venga calcolato un nuovo valore del timer . Questa è la lunghezza del passo
  • factor : il divario tra il vecchio e il successivo valore del timer . Questa è l' altezza del gradino
 (function variableInterval() { //whatever needs to be done interval *= 2; //deal with your interval setTimeout(variableInterval, interval); //whatever needs to be done })(); 

non puoi abbreviare

Crea nuova funzione:

 // set Time interval $("3000,18000").Multitimeout(); jQuery.fn.extend({ Multitimeout: function () { var res = this.selector.split(","); $.each(res, function (index, val) { setTimeout(function () { //...Call function temp(); }, val); }); return true; } }); function temp() { alert(); }