¿Visualizando todos los tiempos de espera / intervalos en javascript?

Estoy escribiendo una aplicación que utiliza tiempos de espera e intervalos de JavaScript para actualizar la página. ¿Hay alguna forma de ver cuántos intervalos están configurados? Quiero asegurarme de que no voy a matar accidentalmente el navegador al configurar cientos de intervalos.

¿Es esto siquiera un problema?

Creo que no hay una forma de enumerar los temporizadores activos, pero se puede anular window.setTimeouty window.clearTimeouty reemplazarlos con sus propias implementaciones que hacen un poco de seguimiento y luego llamar a los originales.

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

Por supuesto, es posible que no siempre llame clearTimeout, pero esto al menos le daría alguna forma de rastrear lo que está sucediendo en tiempo de ejecución.

Hice una extensión de Chrome DevTools que muestra todos los intervalos. Los borrados están en gris.

setInterval-sniffer

Dado que Paul solo ha cubierto setTimeout, pensé en compartir un contador para 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);
};

En lugar de solo tener un conteo de temporizadores, aquí hay una implementación que almacena todos los identificadores de temporizador en una matriz. Solo muestra temporizadores activos mientras que la respuesta aceptada solo cuenta las llamadas 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));

Así es como puede obtener el recuento de temporizadores activos en la página:

timers.length;

Así es como puede eliminar todos los temporizadores activos :

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

Limitaciones conocidas:

• Solo puede pasar una función (no una cadena) setTimeoutcon este parche de mono.
• La función asume clearIntervaly clearTimeouthace lo mismo, lo que hacen pero podría cambiar en el futuro.

Acabamos de publicar un paquete que resuelve este problema exacto.

npm install time-events-manager

Con eso, puede verlos y administrarlos a través de timeoutCollectionobjetos (y los intervalos de JavaScript a través de intervalCollectionobjetos).

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

Solo necesitaba algo como esto y esto es lo que he reunido:

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

Esto registra el intervalo ids junto con sus funciones y también realiza un seguimiento de su estado ( active/ inactive).