Warum "bricht" setTimeout () für große Millisekunden-Verzögerungswerte?

Ich bin auf ein unerwartetes Verhalten gestoßen, als ich einen großen Millisekundenwert an übergeben habe setTimeout(). Zum Beispiel,

setTimeout(some_callback, Number.MAX_VALUE);

und

setTimeout(some_callback, Infinity);

beide führen some_callbackdazu, dass sie fast sofort ausgeführt werden, als hätte ich 0anstelle einer großen Zahl die Verzögerung überschritten .

Warum passiert das?

Dies liegt daran, dass setTimeout ein 32-Bit-int verwendet, um die Verzögerung so zu speichern, dass der maximal zulässige Wert wäre

2147483647

wenn du es versuchst

2147483648

Sie bekommen Ihr Problem auftreten.

Ich kann nur vermuten, dass dies eine interne Ausnahme in der JS Engine verursacht und dazu führt, dass die Funktion sofort und überhaupt nicht ausgelöst wird.

Sie können verwenden:

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

Einige Erklärungen hier: http://closure-library.googlecode.com/svn/docs/closure_goog_timer_timer.js.source.html

Timeout-Werte, die zu groß sind, um in eine vorzeichenbehaftete 32-Bit-Ganzzahl zu passen, können zu einem Überlauf in FF, Safari und Chrome führen, sodass das Timeout sofort geplant wird. Es ist sinnvoller, diese Zeitüberschreitungen einfach nicht zu planen, da 24,8 Tage keine vernünftige Erwartung darstellen, dass der Browser geöffnet bleibt.

Schauen Sie sich das Knotendokument zu Timern hier an: https://nodejs.org/api/timers.html (vorausgesetzt, dass dies auch für js gilt, da es sich derzeit um einen so allgegenwärtigen Begriff handelt, der auf Ereignisschleifen basiert

Zusamenfassend:

Wenn die Verzögerung größer als 2147483647 oder kleiner als 1 ist, wird die Verzögerung auf 1 gesetzt.

und Verzögerung ist:

Die Anzahl der Millisekunden, die gewartet werden muss, bevor der Rückruf aufgerufen wird.

Scheint, als würde Ihr Timeout-Wert nach diesen Regeln standardmäßig auf einen unerwarteten Wert gesetzt, möglicherweise?

Ich bin darauf gestoßen, als ich versucht habe, einen Benutzer mit einer abgelaufenen Sitzung automatisch abzumelden. Meine Lösung bestand darin, das Timeout nach einem Tag zurückzusetzen und die Funktionalität für die Verwendung von clearTimeout beizubehalten.

Hier ist ein kleines Prototypbeispiel:

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

Verwendung:

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

Und Sie können es mit der stopTimerMethode löschen :

timer.stopTimer();

Ich kann nicht kommentieren, aber um allen Leuten zu antworten. Es nimmt einen vorzeichenlosen Wert an (Sie können offensichtlich keine negativen Millisekunden abwarten). Da der maximale Wert also "2147483647" ist, wenn Sie einen höheren Wert eingeben, beginnt er bei 0.

Grundsätzlich Verzögerung = {VALUE}% 2147483647.

Die Verwendung einer Verzögerung von 2147483648 würde also 1 Millisekunde ergeben, daher sofortiger Prozess.

Number.MAX_VALUE

ist eigentlich keine ganze Zahl. Der maximal zulässige Wert für setTimeout beträgt wahrscheinlich 2 ^ 31 oder 2 ^ 32. Versuchen

parseInt(Number.MAX_VALUE) 

und Sie erhalten 1 zurück statt 1.7976931348623157e + 308.