Pourquoi setTimeout () «s'arrête-t-il» pour des valeurs de délai importantes en millisecondes?

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

setTimeout(some_callback, Number.MAX_VALUE);

et

setTimeout(some_callback, Infinity);

les deux causent some_callbackd'être exécutés presque immédiatement, comme si j'avais passé 0au lieu d'un grand nombre comme retard.

Pourquoi cela arrive-t-il?

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

2147483647

si tu essayes

2147483648

vous obtenez votre problème.

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 plutôt que pas du tout.

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

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

Les valeurs de délai d'expiration trop élevées pour tenir dans un entier 32 bits signé peuvent entraîner un dépassement de capacité dans FF, Safari et Chrome, entraînant la planification immédiate du délai d'expiration. Il est plus logique de ne pas programmer ces délais, car 24,8 jours est au-delà d'une attente raisonnable pour que le navigateur reste ouvert.

Consultez la documentation des nœuds sur les minuteries ici: https://nodejs.org/api/timers.html (en supposant la même chose pour js car c'est un terme tellement omniprésent maintenant basé sur une boucle d'événements

En bref:

Lorsque le délai est supérieur à 2147483647 ou inférieur à 1, le délai sera réglé sur 1.

et le retard est:

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

Il semble que votre valeur de délai d'expiration soit réglée par défaut sur une valeur inattendue selon ces règles, peut-être?

Je suis tombé sur cela lorsque j'ai essayé de déconnecter automatiquement un utilisateur avec une session expirée. Ma solution était de simplement 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);
    }
};

Usage:

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

Et vous pouvez l'effacer avec la stopTimerméthode:

timer.stopTimer();

Je ne peux pas faire de commentaire mais répondre à tout le monde. Cela prend une valeur non signée (vous ne pouvez pas attendre des millisecondes négatives évidemment) Donc, comme la valeur maximale est "2147483647" lorsque vous entrez une valeur plus élevée, elle commence à partir de 0.

En gros, retard = {VALUE}% 2147483647.

Donc, utiliser un délai de 2147483648 équivaudrait à 1 milliseconde, donc instant proc.

Number.MAX_VALUE

n'est en fait pas un entier. La valeur maximale autorisée pour setTimeout est probablement 2 ^ 31 ou 2 ^ 32. Essayer

parseInt(Number.MAX_VALUE) 

et vous obtenez 1 en retour au lieu de 1.7976931348623157e + 308.