Por que setTimeout () “interrompe” para grandes valores de atraso de milissegundos?

Eu me deparei com um comportamento inesperado ao passar um grande valor em milissegundos para setTimeout(). Por exemplo,

setTimeout(some_callback, Number.MAX_VALUE);

e

setTimeout(some_callback, Infinity);

ambos fazem some_callbackcom que seja executado quase imediatamente, como se eu tivesse passado em 0vez de um grande número como o atraso.

Por que isso acontece?

Isso se deve ao setTimeout usando um int de 32 bits para armazenar o atraso, de modo que o valor máximo permitido seja

2147483647

se você tentar

2147483648

você consegue seu problema ocorrendo.

Só posso presumir que isso está causando alguma forma de exceção interna no JS Engine e fazendo com que a função seja acionada imediatamente, em vez de não disparar.

Você pode usar:

function runAtDate(date, func) {
    var now = (new Date()).getTime();
    var then = date.getTime();
    var diff = Math.max((then - now), 0);
    if (diff > 0x7FFFFFFF) //setTimeout limit is MAX_INT32=(2^31-1)
        setTimeout(function() {runAtDate(date, func);}, 0x7FFFFFFF);
    else
        setTimeout(func, diff);
}

Algumas explicações aqui: http://closure-library.googlecode.com/svn/docs/closure_goog_timer_timer.js.source.html

Valores de tempo limite muito grandes para caber em um inteiro de 32 bits assinado podem causar estouro no FF, Safari e Chrome, resultando no tempo limite sendo agendado imediatamente. Faz mais sentido simplesmente não agendar esses tempos limites, já que 24,8 dias está além da expectativa razoável para o navegador permanecer aberto.

Verifique a documentação do nó sobre Timers aqui: https://nodejs.org/api/timers.html (assumindo o mesmo em js, já que é um termo tão onipresente agora baseado em loop de evento

Em resumo:

Quando o atraso for maior que 2147483647 ou menor que 1, o atraso será definido como 1.

e o atraso é:

O número de milissegundos a aguardar antes de chamar o retorno de chamada.

Parece que seu valor de tempo limite está sendo padronizado para um valor inesperado ao longo dessas regras, possivelmente?

Tropecei nisso quando tentei fazer logout automático de um usuário com uma sessão expirada. Minha solução foi apenas zerar o tempo limite após um dia e manter a funcionalidade para usar o clearTimeout.

Aqui está um pequeno exemplo de protótipo:

Timer = function(execTime, callback) {
    if(!(execTime instanceof Date)) {
        execTime = new Date(execTime);
    }

    this.execTime = execTime;
    this.callback = callback;

    this.init();
};

Timer.prototype = {

    callback: null,
    execTime: null,

    _timeout : null,

    /**
     * Initialize and start timer
     */
    init : function() {
        this.checkTimer();
    },

    /**
     * Get the time of the callback execution should happen
     */
    getExecTime : function() {
        return this.execTime;
    },

    /**
     * Checks the current time with the execute time and executes callback accordingly
     */
    checkTimer : function() {
        clearTimeout(this._timeout);

        var now = new Date();
        var ms = this.getExecTime().getTime() - now.getTime();

        /**
         * Check if timer has expired
         */
        if(ms <= 0) {
            this.callback(this);

            return false;
        }

        /**
         * Check if ms is more than one day, then revered to one day
         */
        var max = (86400 * 1000);
        if(ms > max) {
            ms = max;
        }

        /**
         * Otherwise set timeout
         */
        this._timeout = setTimeout(function(self) {
            self.checkTimer();
        }, ms, this);
    },

    /**
     * Stops the timeout
     */
    stopTimer : function() {
        clearTimeout(this._timeout);
    }
};

Uso:

var timer = new Timer('2018-08-17 14:05:00', function() {
    document.location.reload();
});

E você pode limpá-lo com o stopTimermétodo:

timer.stopTimer();

Não posso comentar senão responder a todas as pessoas. Leva um valor sem sinal (você não pode esperar milissegundos negativos obviamente) Então, como o valor máximo é "2147483647", quando você insere um valor mais alto, ele começa a partir de 0.

Basicamente, atraso = {VALUE}% 2147483647.

Portanto, usar o atraso de 2147483648 aumentaria 1 milissegundo, portanto, proc instantâneo.

Number.MAX_VALUE

na verdade não é um número inteiro. O valor máximo permitido para setTimeout é provavelmente 2 ^ 31 ou 2 ^ 32. Experimentar

parseInt(Number.MAX_VALUE) 

e você recebe 1 de volta em vez de 1,7976931348623157e + 308.