javascript: pause setTimeout ();

119

Se eu tiver um tempo limite ativo em execução configurado var t = setTimeout("dosomething()", 5000),

Existe alguma maneira de pausar e retomá-lo?


Existe alguma maneira de obter o tempo restante no tempo limite atual?
ou eu tenho que em uma variável, quando o timeout está definido, armazenar a hora atual, então fazemos uma pausa, pegamos a diferença entre agora e então?

Hailwood
fonte
1
Para aqueles que estão se perguntando, a pausa é por exemplo: um div é definido para desaparecer em 5 segundos, em 3 segundos (faltando 2 segundos) o usuário passa o mouse sobre o div, você pausa o tempo limite, uma vez que o usuário desliga o div você o retoma, 2 segundos depois ele desaparece.
Hailwood

Respostas:

260

Você poderia embrulhar window.setTimeoutassim, que eu acho que é semelhante ao que você estava sugerindo na pergunta:

var Timer = function(callback, delay) {
    var timerId, start, remaining = delay;

    this.pause = function() {
        window.clearTimeout(timerId);
        remaining -= Date.now() - start;
    };

    this.resume = function() {
        start = Date.now();
        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();
Tim Down
fonte
3
@yckart: Revertido, desculpe. É uma boa adição, exceto que adicionar parâmetros adicionais a setTimeout()não funciona no Internet Explorer <= 9.
Tim Down
4
Se você fizer timer.resume(); timer.resume();isso, terá dois tempos limite paralelos. É por isso que você deseja clearTimeout(timerId)primeiro ou fazer um if (timerId) return;curto-circuito logo no início do currículo.
kernel
2
Ei, gostei dessa resposta, mas tive que puxar: var timerId, start, remaining;fora do escopo de classe e adicionar de remaining = delay;volta para dentro para capturar o parâmetro. Funciona como um encanto tho!
phillihp
1
@ Josh979: Você realmente não precisa fazer isso e é uma má ideia fazer porque expõe variáveis ​​que deveriam ser internas. Talvez você tenha colado o código dentro de um bloco (por exemplo, dentro de um if (blah) { ... }) ou algo assim?
Tim Down
1
Por algum motivo, isso só é executado uma vez para mim após ser inicializado.
peterxz
17

Algo assim deve resolver o problema.

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 };
}
Sean Vieira
fonte
Mudei +new Date()para new Date().getTime()uma vez que é mais rápido: jsperf.com/date-vs-gettime
yckart
9

Não. Você precisará cancelar ( clearTimeout), medir o tempo desde que você iniciou e reiniciá-lo com o novo tempo.

RoToRa
fonte
7

Uma versão ligeiramente modificada da resposta de Tim Downs . No entanto, uma vez que Tim reverteu minha edição, tenho que responder isso sozinho. Minha solução torna possível usar extra argumentscomo terceiro (3, 4, 5 ...) parâmetro e limpar o cronômetro:

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

Como o Tim mencionou, parâmetros extras não estão disponíveis no IE lt 9, no entanto, trabalhei um pouco para que funcionasse no oldIEdo também.

Uso: 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;
Yckart
fonte
6

"Pausar" e "retomar" não fazem muito sentido no contexto de setTimeout, o que é algo pontual . Você quer dizer setInterval? Se sim, não, você não pode pausá-lo, você pode apenas cancelá-lo ( clearInterval) e, em seguida, reajustá-lo novamente. Detalhes de tudo isso na seção Timers das especificações.

// 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);
TJ Crowder
fonte
16
No contexto de setTimeout, pause e resume ainda fazem sentido.
dbkaplun
6

O Timeout foi fácil de encontrar uma solução, mas o Interval foi um pouco mais complicado.

Eu criei as duas classes a seguir para resolver esses problemas:

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

Eles podem ser implementados como:

var pt_hey = new PauseableTimeout(function(){
    alert("hello");
}, 2000);

window.setTimeout(function(){
    pt_hey.pause();
}, 1000);

window.setTimeout("pt_hey.start()", 2000);

Este exemplo definirá um tempo limite pausável (pt_hey) que está programado para alertar, "hey" após dois segundos. Outro tempo limite pausa o pt_hey após um segundo. Um terceiro tempo limite retoma o pt_hey após dois segundos. pt_hey é executado por um segundo, pausa por um segundo e, em seguida, retoma a execução. pt_hey dispara após três segundos.

Agora, para os intervalos mais complicados

var pi_hey = new PauseableInterval(function(){
    console.log("hello world");
}, 2000);

window.setTimeout("pi_hey.pause()", 5000);

window.setTimeout("pi_hey.resume()", 6000);

Este exemplo define um intervalo pausável (pi_hey) para escrever "hello world" no console a cada dois segundos. Um tempo limite pausa pi_hey após cinco segundos. Outro tempo limite recomeça pi_hey após seis segundos. Então pi_hey irá disparar duas vezes, correr por um segundo, pausar por um segundo, correr por um segundo e então continuar disparando a cada 2 segundos.

OUTRAS FUNÇÕES

  • clearTimeout () e clearInterval ()

    pt_hey.clearTimeout();e pi_hey.clearInterval();serve como uma maneira fácil de limpar os tempos limite e intervalos.

  • getTimeLeft ()

    pt_hey.getTimeLeft();e pi_hey.getTimeLeft();retornará quantos milissegundos até que o próximo gatilho esteja programado para ocorrer.

TheCrzyMan
fonte
Você pode explicar seus pensamentos, por que precisamos de uma classe complexa para pausar um setInterval? Acho que um simples if(!true) return;vai resolver o problema, ou estou errado?
Yckart
2
Eu fiz isso para que você possa literalmente pausar o intervalo, em vez de apenas pular uma chamada quando ela for acionada. Se, em um jogo, um power-up for liberado a cada 60 segundos e eu pausar o jogo um pouco antes de ele iniciar, usando o seu método, terei que esperar mais um minuto para outro power-up. Isso não é realmente uma pausa, é apenas ignorar uma chamada. Em vez disso, Meu método está realmente pausando e, portanto, o power-up é liberado 'no prazo' em relação ao jogo.
TheCrzyMan de
2

Eu precisava calcular o tempo decorrido e restante para mostrar uma barra de progresso. Não foi fácil usar a resposta aceita. 'setInterval' é melhor do que 'setTimeout' para esta tarefa. Então, criei essa classe Timer que você pode usar em qualquer projeto.

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();
    });
Ashraf Fayad
fonte
2

/reviver

Versão ES6 usando açúcar sintático Class-y 💋

(ligeiramente modificado: adicionado start ())

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>

jeremiah.trein
fonte
1

Você poderia olhar em clearTimeout ()

ou pausar dependendo de uma variável global que é definida quando uma determinada condição é atingida. Como se um botão fosse pressionado.

  <button onclick="myBool = true" > pauseTimeout </button>

  <script>
  var myBool = false;

  var t = setTimeout(function() {if (!mybool) {dosomething()}}, 5000);
  </script>
John Hartsock
fonte
1

Você também pode implementá-lo com eventos.

Em vez de calcular a diferença de tempo, você começa e para de ouvir um evento 'tick' que continua em execução em segundo plano:

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

};
meleyal
fonte
1

Se você estiver usando jquery de qualquer maneira, verifique o plugin $ .doTimeout . Essa coisa é uma grande melhoria em relação ao setTimeout, incluindo permitir que você mantenha o controle de seus tempos limite com um único id de string que você especifica e que não muda toda vez que você o configura, e implementa cancelamento fácil, loops de pesquisa e eliminação de pontos e Mais. Um dos meus plug-ins jquery mais usados.

Infelizmente, ele não oferece suporte para pausa / retomada fora da caixa. Para isso, você precisaria quebrar ou estender $ .doTimeout, provavelmente de forma semelhante à resposta aceita.

Ben Roberts
fonte
Eu esperava que doTimeout tivesse pausado / retomado, mas não estou vendo isso ao olhar a documentação completa, exemplos de loop e até mesmo a fonte. O mais próximo da pausa que consegui ver foi cancelar, mas então teria que recriar o temporizador com a função novamente. Perdi alguma coisa?
ericslaw
Desculpe conduzi-lo pelo caminho errado. Removi essa imprecisão da minha resposta.
Ben Roberts
1

Eu precisava ser capaz de pausar setTimeout () para um recurso semelhante a uma apresentação de slides.

Aqui está minha própria implementação de um cronômetro pausável. Ele integra comentários vistos na resposta de Tim Down, como uma pausa melhor (comentário do kernel) e uma forma de prototipagem (comentário de Umur Gedik).

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 */

Exemplo:

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

Para testar o código, use timer.resume()e timer.pause()algumas vezes e verifique quanto tempo resta. (Certifique-se de que seu console esteja aberto.)

Usar este objeto no lugar de setTimeout () é tão fácil quanto substituir timerID = setTimeout( mycallback, 1000)por timer = new Timer( mycallback, 1000 ). Então timer.pause()e timer.resume()estão disponíveis para você.

Fabien Snauwaert
fonte
1
function delay (ms)   {  return new Promise(resolve => setTimeout(resolve, s));  }

demonstração de trabalho "async" em: site zarsoft.info

Joe Oliver
fonte
0

Implementação de texto digitado com base na resposta com melhor classificação

/** Represents the `setTimeout` with an ability to perform pause/resume actions */
export class Timer {
    private _start: Date;
    private _remaining: number;
    private _durationTimeoutId?: NodeJS.Timeout;
    private _callback: (...args: any[]) => void;
    private _done = false;
    get done () {
        return this._done;
    }

    constructor(callback: (...args: any[]) => void, ms = 0) {
        this._callback = () => {
            callback();
            this._done = true;
        };
        this._remaining = ms;
        this.resume();
    }

    /** pauses the timer */
    pause(): Timer {
        if (this._durationTimeoutId && !this._done) {
            this._clearTimeoutRef();
            this._remaining -= new Date().getTime() - this._start.getTime();
        }
        return this;
    }

    /** resumes the timer */
    resume(): Timer {
        if (!this._durationTimeoutId && !this._done) {
            this._start = new Date;
            this._durationTimeoutId = setTimeout(this._callback, this._remaining);
        }
        return this;
    }

    /** 
     * clears the timeout and marks it as done. 
     * 
     * After called, the timeout will not resume
     */
    clearTimeout() {
        this._clearTimeoutRef();
        this._done = true;
    }

    private _clearTimeoutRef() {
        if (this._durationTimeoutId) {
            clearTimeout(this._durationTimeoutId);
            this._durationTimeoutId = undefined;
        }
    }

}
cuddlemeister
fonte
0

Você pode fazer o seguinte para tornar setTimeout pausável no lado do servidor (Node.js)

const PauseableTimeout = function(callback, delay) {
    var timerId, start, remaining = delay;

    this.pause = function() {
        global.clearTimeout(timerId);
        remaining -= Date.now() - start;
    };

    this.resume = function() {
        start = Date.now();
        global.clearTimeout(timerId);
        timerId = global.setTimeout(callback, remaining);
    };

    this.resume();
};

e você pode verificar como abaixo

var timer = new PauseableTimeout(function() {
    console.log("Done!");
}, 3000);
setTimeout(()=>{
    timer.pause();
    console.log("setTimeout paused");
},1000);

setTimeout(()=>{
    console.log("setTimeout time complete");
},3000)

setTimeout(()=>{
    timer.resume();
    console.log("setTimeout resume again");
},5000)
Manoj Rana
fonte
-1

Não acho que você encontrará nada melhor do que clearTimeout . De qualquer forma, você sempre pode agendar outro tempo limite mais tarde, em vez de "reiniciá-lo".

Nikita Rybak
fonte
-1

Se você tiver vários divs para ocultar, poderá usar um setIntervale vários ciclos para fazer o seguinte:

<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>
Microfone
fonte