Pourquoi setTimeout() "s'arrête" pour les grandes valeurs de délai en millisecondes ?

Question

Je suis tombé sur un comportement inattendu en passant une grande valeur de milliseconde à setTimeout() . Par exemple,

setTimeout(some_callback, Number.MAX_VALUE);

y

setTimeout(some_callback, Infinity);

les deux causent some_callback pour être exécuté presque immédiatement, comme si j'avais passé 0 au lieu d'un grand nombre comme le délai.

Pourquoi cela se produit-il ?

Answer 1

Cela est dû au fait que setTimeout utilise un int de 32 bits pour stocker le délai, de sorte que la valeur maximale autorisée serait la suivante

2147483647

si vous essayez

2147483648

vous obtenez votre problème se produisant.

Je ne peux que supposer que cela provoque une forme d'exception interne dans le moteur JS et que la fonction se déclenche immédiatement au lieu de ne pas se déclencher du tout.

Answer 2

Vous pouvez utiliser :

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

Answer 3

Quelques explications ici : http://closure-library.googlecode.com/svn/docs/closure_goog_timer_timer.js.source.html

Les valeurs de délai d'attente trop grandes pour tenir dans un entier signé de 32 bits peuvent provoquer un débordement dans FF, Safari et Chrome, ce qui a pour conséquence que le délai d'attente est immédiatement. Il est plus logique de ne pas programmer ces délais d'attente, puisque 24,8 jours sont au-delà de ce qui est raisonnable pour que le navigateur reste ouvert.

Answer 4

Consultez le document sur les minuteries ici : https://nodejs.org/api/timers.html (je suppose qu'il en va de même pour js puisque c'est un terme omniprésent dans les boucles d'événements).

En bref :

Lorsque le délai est supérieur à 2147483647 ou inférieur à 1, le délai est fixé à 1.

et le retard est :

Le nombre de millisecondes à attendre avant d'appeler le callback.

Il semble que la valeur de votre délai d'attente soit fixée par défaut à une valeur inattendue selon ces règles, peut-être ?

Answer 5

Je suis tombé sur ceci lorsque j'ai essayé de déconnecter automatiquement un utilisateur dont la session a expiré. Ma solution a été de réinitialiser le délai d'expiration après un jour, et de conserver la fonctionnalité permettant d'utiliser clearTimeout.

Voici un petit exemple de prototype :

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

Utilisation :

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

Et vous pouvez l'effacer avec le stopTimer méthode :

timer.stopTimer();