Dlaczego metoda setTimeout () „przerywa” przy dużych milisekundowych wartościach opóźnienia?

Podczas przekazywania dużej wartości w milisekundach do setTimeout(). Na przykład,

setTimeout(some_callback, Number.MAX_VALUE);

i

setTimeout(some_callback, Infinity);

oba powodują, some_callbackże są uruchamiane niemal natychmiast, jakbym przeszedł 0zamiast dużej liczby jako opóźnienie.

Dlaczego to się dzieje?

Wynika to z faktu, że funkcja setTimeout używa 32-bitowej wartości int do przechowywania opóźnienia, więc maksymalna dozwolona wartość byłaby

2147483647

Jeśli spróbujesz

2147483648

masz problem.

Mogę tylko przypuszczać, że powoduje to jakąś formę wewnętrznego wyjątku w silniku JS i powoduje natychmiastowe uruchomienie funkcji, a nie wcale.

Możesz użyć:

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

Oto kilka wyjaśnień: http://closure-library.googlecode.com/svn/docs/closure_goog_timer_timer.js.source.html

Wartości limitu czasu zbyt duże, aby zmieścić się w 32-bitowej liczbie całkowitej ze znakiem, mogą powodować przepełnienie w FF, Safari i Chrome, powodując natychmiastowe zaplanowanie limitu czasu. Bardziej sensowne jest po prostu nie planowanie tych limitów czasu, ponieważ 24,8 dni to ponad rozsądne oczekiwanie, że przeglądarka pozostanie otwarta.

Sprawdź dokumentację dotyczącą węzłów na temat timerów tutaj: https://nodejs.org/api/timers.html (zakładając to samo również w js, ponieważ jest to tak wszechobecny termin teraz w pętli zdarzeń

W skrócie:

Gdy opóźnienie jest większe niż 2147483647 lub mniejsze niż 1, opóźnienie zostanie ustawione na 1.

a opóźnienie wynosi:

Liczba milisekund oczekiwania przed wywołaniem wywołania zwrotnego.

Wygląda na to, że zgodnie z tymi regułami wartość limitu czasu jest domyślnie ustawiona na nieoczekiwaną wartość?

Natknąłem się na to, gdy próbowałem automatycznie wylogować użytkownika z wygasłą sesją. Moim rozwiązaniem było po prostu zresetowanie limitu czasu po jednym dniu i zachowanie funkcji korzystania z clearTimeout.

Oto mały przykład prototypu:

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

Stosowanie:

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

I możesz to wyczyścić stopTimermetodą:

timer.stopTimer();

Nie mogę komentować, ale odpowiedzieć wszystkim ludziom. Pobiera wartość bez znaku (oczywiście nie możesz czekać ujemnych milisekund), więc ponieważ wartość maksymalna to „2147483647”, kiedy wprowadzasz wyższą wartość, zaczyna się od 0.

Zasadniczo opóźnienie = {VALUE}% 2147483647.

Więc użycie opóźnienia 2147483648 sprawiłoby, że 1 milisekunda byłby natychmiastowy.

Number.MAX_VALUE

w rzeczywistości nie jest liczbą całkowitą. Maksymalna dopuszczalna wartość setTimeout to prawdopodobnie 2 ^ 31 lub 2 ^ 32. Próbować

parseInt(Number.MAX_VALUE) 

i otrzymujesz 1 z powrotem zamiast 1,7976931348623157e + 308.