Gibt es eine Möglichkeit, alle Zeitüberschreitungen in einem bestimmten Fenster zu löschen? Ich nehme an, die Zeitüberschreitungen sind irgendwo im windowObjekt gespeichert , konnten dies aber nicht bestätigen.

Jede Cross-Browser-Lösung ist willkommen.

Sie befinden sich nicht im Fensterobjekt, aber sie haben IDs, die (afaik) aufeinanderfolgende ganze Zahlen sind.

So können Sie alle Zeitüberschreitungen wie folgt löschen:

var id = window.setTimeout(function() {}, 0);

while (id--) {
    window.clearTimeout(id); // will do nothing if no timeout with id is present
}

Ich denke, der einfachste Weg, dies zu erreichen, besteht darin, alle setTimeoutBezeichner in einem Array zu speichern , zu dem Sie clearTimeout()auf allen leicht iterieren können.

var timeouts = [];
timeouts.push(setTimeout(function(){alert(1);}, 200));
timeouts.push(setTimeout(function(){alert(2);}, 300));
timeouts.push(setTimeout(function(){alert(3);}, 400));

for (var i=0; i<timeouts.length; i++) {
  clearTimeout(timeouts[i]);
}

Ich habe eine Ergänzung zu Pumbaa80s Antwort , die für jemanden nützlich sein könnte, der sich für alte IEs entwickelt.

Ja, alle gängigen Browser implementieren Timeout-IDs als aufeinanderfolgende Ganzzahlen (was in der Spezifikation nicht erforderlich ist ). Obwohl die Startnummer von Browser zu Browser unterschiedlich ist. Es scheint, dass Opera, Safari, Chrome und IE> 8 Timeout-IDs von 1, Gecko-basierte Browser von 2 und IE <= 8 von einer Zufallszahl aus starten, die bei der Aktualisierung von Registerkarten auf magische Weise gespeichert wird. Sie können es selbst entdecken .

Alles, was bedeutet, dass der while (lastTimeoutId--)Zyklus in IE <= 8 mehr als 8 -stellig ausgeführt werden kann und die Meldung " Ein Skript auf dieser Seite bewirkt, dass Internet Explorer langsam ausgeführt wird " angezeigt wird. Wenn Sie also nicht alle Timeout- IDs speichern können oder window.setTimeout nicht überschreiben möchten , können Sie die erste Timeout-ID auf einer Seite speichern und Timeouts bis dahin löschen .

Führen Sie den Code beim frühen Laden der Seite aus:

var clearAllTimeouts = (function () {
    var noop = function () {},
        firstId = window.setTimeout(noop, 0);
    return function () {
        var lastId = window.setTimeout(noop, 0);
        console.log('Removing', lastId - firstId, 'timeout handlers');
        while (firstId != lastId)
            window.clearTimeout(++firstId);
    };
});

Und löschen Sie dann alle ausstehenden Zeitüberschreitungen, die wahrscheinlich so oft durch Fremdcode festgelegt wurden, wie Sie möchten

Wie wäre es, wenn Sie die Timeout-IDs in einem globalen Array speichern und eine Methode definieren, um den Funktionsaufruf an die Fenster zu delegieren.

GLOBAL={
    timeouts : [],//global timeout id arrays
    setTimeout : function(code,number){
        this.timeouts.push(setTimeout(code,number));
    },
    clearAllTimeout :function(){
        for (var i=0; i<this.timeouts.length; i++) {
            window.clearTimeout(this.timeouts[i]); // clear all the timeouts
        }
        this.timeouts= [];//empty the id array
    }
};

Sie müssen die window.setTimeoutMethode neu schreiben und ihre Timeout-ID speichern.

const timeouts = [];
const originalTimeoutFn = window.setTimeout;

window.setTimeout = function(fun, delay) { //this is over-writing the original method
  const t = originalTimeoutFn(fn, delay);
  timeouts.push(t);
}

function clearTimeouts(){
  while(timeouts.length){
    clearTimeout(timeouts.pop();
  }
}

Um alle zu löschen Timeouts sie müssen „eingefangen“ werden zuerst :

Platzieren Sie den folgenden Code vor jedem anderen Skript und es wird eine Wrapper-Funktion für das Original setTimeout& erstellt clearTimeout.

Dem Objekt werden neue clearTimeoutsMethoden hinzugefügt window, mit denen alle (ausstehenden) Zeitüberschreitungen gelöscht werden können ( Link Link ).

Andere Antworten haben keine vollständige Unterstützung für mögliche Argumente setTimeout .

// isolated layer wrapper (for the local variables)
(function(_W){

var cache = [],                // will store all timeouts IDs
    _set = _W.setTimeout,      // save original reference
    _clear = _W.clearTimeout  // save original reference

// Wrap original setTimeout with a function 
_W.setTimeout = function( CB, duration, arg ){
    // also, wrap the callback, so the cache reference will be removed 
    // when the timeout has reached (fired the callback)
    var id = _set(function(){
        CB.apply(null, arguments)
        removeCacheItem(id)
    }, duration || 0, arg)

    cache.push( id ) // store reference in the cache array

    // id reference must be returned to be able to clear it 
    return id
}

// Wrap original clearTimeout with a function 
_W.clearTimeout = function( id ){
    _clear(id)
    removeCacheItem(id)
}

// Add a custom function named "clearTimeouts" to the "window" object
_W.clearTimeouts = function(){
    console.log("Clearing " + cache.length + " timeouts")
    cache.forEach(n => _clear(n))
    cache.length = []
}

// removes a specific id from the cache array 
function removeCacheItem( id ){
    var idx = cache.indexOf(id)

    if( idx > -1 )
        cache = cache.filter(n => n != id )
}

})(window);

Der Vollständigkeit halber wollte ich eine allgemeine Lösung veröffentlichen, die sowohl setTimeoutals auch abdeckt setInterval.

Es scheint, dass Browser für beide denselben ID-Pool verwenden, aber aus einigen Antworten auf Sind clearTimeout und clearInterval gleich? Es ist nicht klar, ob es sicher ist, sich auf dieselbe Funktion zu verlassen clearTimeoutund clearIntervalsie auszuführen oder nur an ihren jeweiligen Timertypen zu arbeiten.

Wenn das Ziel darin besteht, alle Zeitüberschreitungen und Intervalle zu beenden, finden Sie hier eine Implementierung, die bei Implementierungen möglicherweise etwas defensiver ist, wenn nicht alle getestet werden können:

function clearAll(windowObject) {
  var id = Math.max(
    windowObject.setInterval(noop, 1000),
    windowObject.setTimeout(noop, 1000)
  );

  while (id--) {
    windowObject.clearTimeout(id);
    windowObject.clearInterval(id);
  }

  function noop(){}
}

Sie können damit alle Timer im aktuellen Fenster löschen:

clearAll(window);

Oder Sie können es verwenden, um alle Timer in einem iframe:

clearAll(document.querySelector("iframe").contentWindow);

Ich benutze Vue mit Typescript.

    private setTimeoutN;
    private setTimeoutS = [];

    public myTimeoutStart() {

        this.myTimeoutStop();//stop All my timeouts

        this.setTimeoutN = window.setTimeout( () => {
            console.log('setTimeout');
        }, 2000);

        this.setTimeoutS.push(this.setTimeoutN)//add THIS timeout ID in array

    }

    public myTimeoutStop() {

        if( this.setTimeoutS.length > 0 ) {
            for (let id in this.setTimeoutS) {
                console.log(this.setTimeoutS[id]);
                clearTimeout(this.setTimeoutS[id]);
            }
            this.setTimeoutS = [];//clear IDs array
        }
    }

Verwenden Sie ein globales Timeout, von dem alle anderen Funktionen das Timing ableiten. Dadurch wird alles schneller ausgeführt und einfacher zu verwalten, obwohl Ihr Code dadurch etwas abstrahiert wird.

Wir haben gerade ein Paket veröffentlicht, das genau dieses Problem löst.

npm install time-events-manager

Damit können Sie alle Timeouts und Intervalle über timeoutCollection& intervalCollectionObjekte anzeigen . Es gibt auch eine removeAllFunktion, die alle Zeitüberschreitungen / Intervalle sowohl aus der Sammlung als auch aus dem Browser löscht.