Mengapa setTimeout () "istirahat" untuk nilai penundaan milidetik yang besar?

Saya menemukan beberapa perilaku yang tidak terduga saat meneruskan nilai milidetik yang besar ke setTimeout(). Misalnya,

setTimeout(some_callback, Number.MAX_VALUE);

dan

setTimeout(some_callback, Infinity);

keduanya menyebabkan some_callbackuntuk dijalankan hampir seketika, seolah-olah saya telah lulus 0bukannya sejumlah besar sebagai penundaan.

Mengapa ini terjadi?

Ini karena setTimeout menggunakan int 32 bit untuk menyimpan penundaan sehingga nilai maksimal yang diizinkan

2147483647

jika kamu mencoba

2147483648

Anda mendapatkan masalah Anda terjadi.

Saya hanya dapat berasumsi bahwa ini menyebabkan beberapa bentuk pengecualian internal di JS Engine dan menyebabkan fungsi langsung aktif daripada tidak sama sekali.

Kamu bisa memakai:

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

Beberapa penjelasan di sini: http://closure-library.googlecode.com/svn/docs/closure_goog_timer_timer.js.source.html

Nilai waktu tunggu yang terlalu besar untuk dimasukkan ke dalam bilangan bulat 32-bit yang ditandatangani dapat menyebabkan luapan di FF, Safari, dan Chrome, sehingga waktu tunggu akan segera dijadwalkan. Lebih masuk akal untuk tidak menjadwalkan waktu tunggu ini, karena 24,8 hari adalah di luar ekspektasi yang wajar agar browser tetap terbuka.

Lihat dokumen node di Timer di sini: https://nodejs.org/api/timers.html (dengan asumsi yang sama di js juga karena itu istilah yang ada di mana-mana sekarang dalam event loop based

Pendeknya:

Jika penundaan lebih besar dari 2147483647 atau kurang dari 1, penundaan akan disetel ke 1.

dan penundaan adalah:

Jumlah milidetik untuk menunggu sebelum memanggil callback.

Sepertinya nilai waktu tunggu Anda disetel secara default ke nilai yang tidak terduga sesuai aturan ini, mungkin?

Saya tersandung pada ini ketika saya mencoba untuk mengeluarkan pengguna secara otomatis dengan sesi yang kedaluwarsa. Solusi saya adalah mengatur ulang waktu tunggu setelah satu hari, dan tetap menggunakan fungsionalitas untuk menggunakan clearTimeout.

Berikut adalah contoh prototipe kecil:

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

Pemakaian:

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

Dan Anda dapat menghapusnya dengan stopTimermetode:

timer.stopTimer();

Tidak bisa berkomentar selain menjawab semua orang. Dibutuhkan nilai unsigned (Anda tidak bisa menunggu milidetik negatif jelas) Jadi karena nilai maks adalah "2147483647" ketika Anda memasukkan nilai yang lebih tinggi itu mulai pergi dari 0.

Pada dasarnya penundaan = {VALUE}% 2147483647.

Jadi menggunakan penundaan 2147483648 akan menjadikannya 1 milidetik, oleh karena itu, proses instan.

Number.MAX_VALUE

sebenarnya bukan bilangan bulat. Nilai maksimum yang diizinkan untuk setTimeout kemungkinan adalah 2 ^ 31 atau 2 ^ 32. Mencoba

parseInt(Number.MAX_VALUE) 

dan Anda mendapatkan 1 kembali, bukan 1.7976931348623157e + 308.