¿Por qué setTimeout () se “rompe” para valores de retardo de milisegundos grandes?

Me encontré con un comportamiento inesperado al pasar un gran valor de milisegundos a setTimeout(). Por ejemplo,

setTimeout(some_callback, Number.MAX_VALUE);

y

setTimeout(some_callback, Infinity);

ambos causan some_callbackque se ejecuten casi de inmediato, como si hubiera pasado en 0lugar de un gran número como retraso.

¿Por qué pasó esto?

Esto se debe a que setTimeout usa un int de 32 bits para almacenar el retraso, por lo que el valor máximo permitido sería

2147483647

si intentas

2147483648

usted consigue que su problema ocurra.

Solo puedo suponer que esto está causando algún tipo de excepción interna en JS Engine y haciendo que la función se active inmediatamente en lugar de no dispararse en absoluto.

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

Alguna explicación aquí: http://closure-library.googlecode.com/svn/docs/closure_goog_timer_timer.js.source.html

Los valores de tiempo de espera demasiado grandes para caber en un entero de 32 bits con signo pueden causar un desbordamiento en FF, Safari y Chrome, lo que hace que el tiempo de espera se programe inmediatamente. Tiene más sentido simplemente no programar estos tiempos de espera, ya que 24,8 días es más que una expectativa razonable para que el navegador permanezca abierto.

Consulte el documento del nodo sobre Timers aquí: https://nodejs.org/api/timers.html (asumiendo lo mismo en js también, ya que ahora es un término tan ubicuo en el bucle de eventos basado

En breve:

Cuando la demora es mayor que 2147483647 o menor que 1, la demora se establecerá en 1.

y el retraso es:

La cantidad de milisegundos que se deben esperar antes de llamar a la devolución de llamada.

¿Parece que su valor de tiempo de espera está predeterminado en un valor inesperado según estas reglas, posiblemente?

Me encontré con esto cuando intenté cerrar la sesión automáticamente de un usuario con una sesión caducada. Mi solución fue restablecer el tiempo de espera después de un día y mantener la funcionalidad para usar clearTimeout.

Aquí hay un pequeño ejemplo de prototipo:

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

Y puedes borrarlo con el stopTimermétodo:

timer.stopTimer();

No puedo comentar, pero responder a todas las personas. Se necesita un valor sin firmar (obviamente, no puede esperar milisegundos negativos). Entonces, dado que el valor máximo es "2147483647", cuando ingresa un valor más alto, comienza a ir desde 0.

Básicamente, retraso = {VALOR}% 2147483647.

Entonces, usar un retraso de 2147483648 lo haría 1 milisegundo, por lo tanto, proceso instantáneo.

Number.MAX_VALUE

en realidad no es un número entero. El valor máximo permitido para setTimeout es probablemente 2 ^ 31 o 2 ^ 32. Tratar

parseInt(Number.MAX_VALUE) 

y obtienes 1 de vuelta en lugar de 1.7976931348623157e + 308.