Perché setTimeout () "si interrompe" per valori di ritardo di millisecondi elevati?

Ho riscontrato un comportamento imprevisto durante il passaggio di un valore elevato in millisecondi a setTimeout(). Per esempio,

setTimeout(some_callback, Number.MAX_VALUE);

e

setTimeout(some_callback, Infinity);

entrambi fanno sì some_callbackche vengano eseguiti quasi immediatamente, come se avessi passato 0invece un gran numero come ritardo.

Perché succede questo?

Ciò è dovuto al fatto che setTimeout utilizza un int a 32 bit per memorizzare il ritardo, quindi il valore massimo consentito sarebbe

2147483647

se provi

2147483648

ottieni il tuo problema che si verifica.

Posso solo presumere che questo stia causando una qualche forma di eccezione interna nel motore JS e causando l'attivazione immediata della funzione piuttosto che per niente.

Puoi usare:

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

Alcune spiegazioni qui: http://closure-library.googlecode.com/svn/docs/closure_goog_timer_timer.js.source.html

Valori di timeout troppo grandi per essere contenuti in un numero intero a 32 bit con segno possono causare un overflow in FF, Safari e Chrome, con conseguente pianificazione immediata del timeout. Ha più senso semplicemente non pianificare questi timeout, poiché 24,8 giorni sono oltre una ragionevole aspettativa per il browser di rimanere aperto.

Controlla il documento del nodo sui timer qui: https://nodejs.org/api/timers.html (assumendo lo stesso anche su js poiché è un termine così onnipresente ora basato sul ciclo di eventi

In breve:

Quando il ritardo è maggiore di 2147483647 o minore di 1, il ritardo verrà impostato su 1.

e il ritardo è:

Il numero di millisecondi da attendere prima di chiamare la richiamata.

Sembra che il tuo valore di timeout venga impostato per impostazione predefinita su un valore inaspettato secondo queste regole, forse?

Mi sono imbattuto in questo quando ho provato a disconnettere automaticamente un utente con una sessione scaduta. La mia soluzione era ripristinare il timeout dopo un giorno e mantenere la funzionalità per utilizzare clearTimeout.

Ecco un piccolo esempio di 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();
});

E puoi cancellarlo con il stopTimermetodo:

timer.stopTimer();

Non posso commentare ma rispondere a tutte le persone. Prende un valore senza segno (ovviamente non puoi aspettare millisecondi negativi) Quindi poiché il valore massimo è "2147483647" quando inserisci un valore più alto, inizia da 0.

Fondamentalmente ritardo = {VALUE}% 2147483647.

Quindi l'utilizzo del ritardo di 2147483648 renderebbe 1 millisecondo, quindi, proc istantaneo.

Number.MAX_VALUE

in realtà non è un numero intero. Il valore massimo consentito per setTimeout è probabilmente 2 ^ 31 o 2 ^ 32. Provare

parseInt(Number.MAX_VALUE) 

e ne ottieni 1 invece di 1.7976931348623157e + 308.