mozilla
Ihre Suchergebnisse

    Window.setTimeout()

    Zusammenfassung

    Ruft eine Funktion aus oder führt einen gegebenen Code nach einer gewissen Zeitspanne aus.

    Syntax

    var timeoutID = window.setTimeout(funktion, zeitspanne, [parameter1, parameter2, ...]);
    var timeoutID = window.setTimeout(code, zeitspanne);
    
    • timeoutID ist die eindeutige numerische ID für das definierte Timeout, die später benutzt werden kann, um das Timeout mit der Funktion window.clearTimeout() abzubrechen.
    • funktion ist die Funktion, die nach zeitspanne Millisekunden ausgeführt werden soll.
    • code in der alternativen Syntax ist eine Zeichenkette, die Code enthält, der nach delay Millisekunden ausgeführt werden soll (es ist nicht angeraten, diese alternative Syntax zu verwenden aus denselben Gründen wie die Verwendung von eval()).
    • zeitspanne ist die Anzahl Millisekunden (ein Tausendstel einer Sekunde), nach der die Funktion (oder der Code) ausgeführt werden soll. Auf die Genauigkeit dieser Zeitspanne sollte man sich nicht stützen (sh. Anmerkungen).

    Es wird angemerkt, dass die zusätzlichen Parameter in der ersten Syntax nicht mit dem Internet Explorer kompatibel sind. Mehr dazu im Paragraphen  Callback Parameter.

    Anmerkung: Vor Gecko 13 (Firefox 13.0 / Thunderbird 13.0 / SeaMonkey 2.10) hat Gecko der Callback-Routine einen zusätzlichen Parameter übergeben. Dieser Parameter enthielt die eigentliche Zeitspanne, nach der die Funktion aufgerufen wurde. Dieser Parameter, der keinem Standard entspricht, wird seit Gecko 13 nicht mehr übergeben.

    Beispiele

    function generateOutput(aConcise) {
        if(aConcise) {
            parent.generateConciseOutput();
        } else {
            parent.generateOutput();
        }
    }
    // wird "true" der Funktion im IE nicht übergeben
    window.setTimeout(generateOutput, 1000, true); 
    
    
    
    // Kompatibilität kann durch eine anonyme erreicht werden.
    setTimeout(function() {
      generateOutput(true);
    }, 1000);  // dies funktioniert in jedem Browser
    
    window.setTimeout("window.parent.generateOutput(true)", 1000);  // veraltet
    

    Sicht auf JSFiddle

    Siehe clearTimeout() Beispiel.

    Callback-Parameter

    Falls Sie der Callback-Funktion Parameter übergeben müssen, dies aber auch im Internet Explorer, der dies weder für setTimeout() noch für setInterval() ermöglicht, können Sie folgenden Kompatibilitätscode am Anfang Ihres Scripts einfügen, der auch dem Internet Explorer ermöglicht, diesen nicht implementierten HTML Standard auszugleichen.

    /*\
    |*|
    |*|  IE-specific polyfill which enables the passage of arbitrary arguments to the
    |*|  callback functions of javascript timers (HTML5 standard syntax).
    |*|
    |*|  https://developer.mozilla.org/en-US/docs/DOM/window.setInterval
    |*|
    |*|  Syntax:
    |*|  var timeoutID = window.setTimeout(func, delay, [param1, param2, ...]);
    |*|  var timeoutID = window.setTimeout(code, delay);
    |*|  var intervalID = window.setInterval(func, delay[, param1, param2, ...]);
    |*|  var intervalID = window.setInterval(code, delay);
    |*|
    \*/
    
    if (document.all && !window.setTimeout.isPolyfill) {
      var __nativeST__ = window.setTimeout;
      window.setTimeout = function (vCallback, nDelay /*, argumentToPass1, argumentToPass2, etc. */) {
        var aArgs = Array.prototype.slice.call(arguments, 2);
        return __nativeST__(vCallback instanceof Function ? function () {
          vCallback.apply(null, aArgs);
        } : vCallback, nDelay);
      };
      window.setTimeout.isPolyfill = true;
    }
    
    if (document.all && !window.setInterval.isPolyfill) {
      var __nativeSI__ = window.setInterval;
      window.setInterval = function (vCallback, nDelay /*, argumentToPass1, argumentToPass2, etc. */) {
        var aArgs = Array.prototype.slice.call(arguments, 2);
        return __nativeSI__(vCallback instanceof Function ? function () {
          vCallback.apply(null, aArgs);
        } : vCallback, nDelay);
      };
      window.setInterval.isPolyfill = true;
    }
    

    Eine andere Möglichkeit ist, die Funktion innerhalb einer anonymen Funktion aufzurufen. Beispiel:

    var intervalID = setTimeout(function() { myFunc("one", "two", "three"); }, 1000);
    

    Das "this" Problem

    Wenn Sie setTimeout() eine Methode (oder irgendeine Funktion in diesem Fall) übergeben, wird in dieser Methode this einen falschen Wert enthalten. Dieses Problem wird detailliert in der JavaScript Referenz beschrieben.

    Erklärung

    Code, der von setTimeout() ausgeführt wird, wird in einem anderen Kontext ausgeführt als in dem, in der er aufgerufen wurde. Das heißt, dass  this in der aufgerufenen Funktion  window (oder global) und nicht das this aus der Funktion, die setTimeout aufgerufen hat, sein wird. Beispiel:

    myArray = ["null", "eins", "drei"];
    myArray.myMethod = function (sProperty) {
        alert(arguments.length > 0 ? this[sProperty] : this);
    };
    
    myArray.myMethod(); // Ausgabe: "null,eins,zwei"
    myArray.myMethod(1); // Ausgabe: "eins"
    setTimeout(myArray.myMethod, 1000); // Ausgabe: "[object Window]" nach 1 Sekunde
    setTimeout(myArray.myMethod, 1500, "1"); // Ausgabe: "undefined" nach 1,5 Sekunden
    // Versuchen wir, 'this' zu übergeben
    setTimeout.call(myArray, myArray.myMethod, 2000); // Fehler: "NS_ERROR_XPC_BAD_OP_ON_WN_PROTO: Illegal operation on WrappedNative prototype object"
    setTimeout.call(myArray, myArray.myMethod, 2500, 2); // Der gleiche Fehler

    As you can see there are no ways to pass the this object to the callback function.

    A possible solution

    A possible way to solve the "this" problem is to replace the two native setTimeout() or setInterval() global functions with two non-native ones which will enable their invocation through the Function.prototype.call method. The following example shows a possible replacement:

    // Enable the passage of the 'this' object through the JavaScript timers
     
    var __nativeST__ = window.setTimeout, __nativeSI__ = window.setInterval;
     
    window.setTimeout = function (vCallback, nDelay /*, argumentToPass1, argumentToPass2, etc. */) {
      var oThis = this, aArgs = Array.prototype.slice.call(arguments, 2);
      return __nativeST__(vCallback instanceof Function ? function () {
        vCallback.apply(oThis, aArgs);
      } : vCallback, nDelay);
    };
     
    window.setInterval = function (vCallback, nDelay /*, argumentToPass1, argumentToPass2, etc. */) {
      var oThis = this, aArgs = Array.prototype.slice.call(arguments, 2);
      return __nativeSI__(vCallback instanceof Function ? function () {
        vCallback.apply(oThis, aArgs);
      } : vCallback, nDelay);
    };
    Note: This two replacements will also enable the HTML5 standard passage of arbitrary arguments to the callback functions of timers in IE. So they can be used as polyfills also. See the Callback arguments paragraph.

    New feature test:

    myArray = ["zero", "one", "two"];
    myArray.myMethod = function (sProperty) {
        alert(arguments.length > 0 ? this[sProperty] : this);
    };
    
    setTimeout(alert, 1500, "Hello world!"); // the standard use of setTimeout and setInterval is preserved, but...
    setTimeout.call(myArray, myArray.myMethod, 2000); // prints "zero,one,two" after 2 seconds
    setTimeout.call(myArray, myArray.myMethod, 2500, 2); // prints "two" after 2,5 seconds
    

    There are not native solutions ad hoc to this problem.

    Note: JavaScript 1.8.5 introduces the Function.prototype.bind() method, which lets you specify the value that should be used as this for all calls to a given function. This lets you easily bypass problems where it's unclear what this will be, depending on the context from which your function was called.

    Notes

    You can cancel the timeout using window.clearTimeout().

    If you wish to have your function called repeatedly (i.e. every N milliseconds), consider using window.setInterval().

    Passing string literals

    Passing a string instead of a function to setTimeout() suffers from the same hazards as using eval.

    // Correct
    window.setTimeout(function() {
        alert("Hello World!");
    }, 500);
    
    // Incorrect
    window.setTimeout("alert(\"Hello World!\");", 500);
    
    

    String literals are evaluated in the global context, so local symbols in the context where setTimeout() was called will not be available when the string is evaluated as code.

    Minimum delay and timeout nesting

    Historically browsers implement setTimeout() "clamping": successive setTimeout() calls with delay smaller than the "minimum delay" limit are forced to the use at least the minimum delay. The minimum delay, DOM_MIN_TIMEOUT_VALUE, is 4 ms (stored in a preference in Firefox: dom.min_timeout_value), with a DOM_CLAMP_TIMEOUT_NESTING_LEVEL of 5ms.

    In fact, 4ms is specified by the HTML5 spec and is consistent across browsers released in 2010 and onward. Prior to (Firefox 5.0 / Thunderbird 5.0 / SeaMonkey 2.2), the minimum timeout value for nested timeouts was 10 ms.

    In addition to "clamping", the timeout can also fire later when the page (or the OS/browser itself) is busy with other tasks.

    To implement a 0 ms timeout in a modern browser you can use window.postMessage() as described here.

    Inactive tabs

    In (Firefox 5.0 / Thunderbird 5.0 / SeaMonkey 2.2) and Chrome 11, timeouts are clamped to firing no more often than once per second (1000ms) in inactive tabs; see Bug 633421 for more information about this in Mozilla or crbug.com/66078 for details about this in Chrome.

    Browser compatibility

    Feature Chrome Firefox (Gecko) Internet Explorer Opera Safari
    Basic support 1.0 1.0 (1.7 oder früher) 4.0 4.0 1.0
    Feature Android Chrome for Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
    Basic support 1.0 1.0 1.0 (1) 6.0 6.0 1.0

    Specification

    Part of DOM level 0, as specified in HTML5.

    See also

    Schlagwörter des Dokuments und Mitwirkende

    Mitwirkende an dieser Seite: c0ffm3k4r, fscholz, wartab
    Zuletzt aktualisiert von: fscholz,
    Seitenleiste ausblenden