Stai visualizzando tutti i timeout / intervalli in javascript?

Sto scrivendo un'applicazione che utilizza timeout e intervalli JavaScript per aggiornare la pagina. C'è un modo per vedere quanti intervalli sono impostati? Voglio essere sicuro di non uccidere accidentalmente il browser impostando centinaia di intervalli.

È anche questo un problema?

Non credo ci sia un modo per enumerare i timer attivi, ma si poteva ignorare window.setTimeoute window.clearTimeoute sostituirli con le proprie implementazioni che fanno un po 'di monitoraggio e quindi chiamare gli originali.

window.originalSetTimeout = window.setTimeout;
window.originalClearTimeout = window.clearTimeout;
window.activeTimers = 0;

window.setTimeout = function(func, delay) {
    window.activeTimers++;
    return window.originalSetTimeout(func, delay);
};

window.clearTimeout = function(timerID) {
    window.activeTimers--;
    window.originalClearTimeout(timerID);
};

Naturalmente, potresti non chiamare sempre clearTimeout, ma questo ti darebbe almeno un modo per tenere traccia di ciò che sta accadendo in fase di esecuzione.

Ho creato un'estensione Chrome DevTools che mostra tutti gli intervalli. Quelli deselezionati sono disattivati.

setInterval-sniffer

Visto che Paul ha coperto solo setTimeout, ho pensato di condividere un contatore per setInterval / clearInterval.

window.originalSetInterval = window.setInterval;
window.originalClearInterval = window.clearInterval;
window.activeIntervals = 0;
window.setInterval = function (func, delay)
{
    if(func && delay){
            window.activeIntervals++;
    }
    return window.originalSetInterval(func,delay);
};
window.clearInterval = function (intervalId)
{
    // JQuery sometimes hands in true which doesn't count
    if(intervalId !== true){
        window.activeIntervals--;
    }
    return window.originalClearInterval(intervalId);
};

Invece di avere solo un conteggio dei timer, ecco un'implementazione che memorizza tutti i timerid in un array. Mostra solo i timer attivi mentre la risposta accettata conta solo le chiamate a setTimeout& clearTimeout.

(function(w) {
    var oldST = w.setTimeout;
    var oldSI = w.setInterval;
    var oldCI = w.clearInterval;
    var timers = [];
    w.timers = timers;
    w.setTimeout = function(fn, delay) {
        var id = oldST(function() {
            fn && fn();
            removeTimer(id);
        }, delay);
        timers.push(id);
        return id;
    };
    w.setInterval = function(fn, delay) {
        var id = oldSI(fn, delay);
        timers.push(id);
        return id;
    };
    w.clearInterval = function(id) {
        oldCI(id);
        removeTimer(id);
    };
    w.clearTimeout = w.clearInterval;

    function removeTimer(id) {
        var index = timers.indexOf(id);
        if (index >= 0)
            timers.splice(index, 1);
    }
}(window));

Ecco come ottenere il conteggio dei timer attivi sulla pagina:

timers.length;

Ecco come rimuovere tutti i timer attivi :

for(var i = timers.length; i--;)
    clearInterval(timers[i]);

Limitazioni note:

• Puoi solo passare una funzione (non una stringa) a setTimeoutcon questa patch scimmia.
• La funzione assume clearIntervale clearTimeoutfa lo stesso, cosa che fanno ma potrebbe cambiare in futuro.

Abbiamo appena pubblicato un pacchetto che risolve esattamente questo problema.

npm install time-events-manager

Con ciò, puoi visualizzarli e gestirli tramite timeoutCollectionoggetto (e gli intervalli di javascript tramite intervalCollectionoggetto).

timeoutCollection.getScheduled(); timeoutCollection.getCompleted(); timeoutCollection.getAll();

Avevo solo bisogno di qualcosa del genere e questo è quello che ho messo insieme:

window.setInterval = function (window, setInterval) {
  if (!window.timers) {
    window.timers = {};
  }
  if (!window.timers.intervals) {
    window.timers.intervals = {};
  }
  if (!window.timers.intervals.active) {
    window.timers.intervals.active = {};
  }
  return function (func, interval) {
    var id = setInterval(func, interval);
    window.timers.intervals.active[id] = func;
    return id;
  }
}(window, window.setInterval);

window.clearInterval = function (window, clearInterval) {
  if (!window.timers) {
    window.timers = {};
  }
  if (!window.timers.intervals) {
    window.timers.intervals = {};
  }
  if (!window.timers.intervals.inactive) {
    window.timers.intervals.inactive = {};
  }
  return function (id) {
    if (window.timers.intervals.active && window.timers.intervals.active[id]) {
      window.timers.intervals.inactive[id] = window.timers.intervals.active[id];
      clearInterval(id);
      delete window.timers.intervals.active[id];
    }
  }
}(window, window.clearInterval);

Questo registra gli intervalli idinsieme alle loro funzioni e tiene traccia del loro stato ( active/ inactive).