Apelează o funcție sau execută un fragment de cod după o durată specificată.
Sintaxă
var timeoutID = window.setTimeout(func, delay, [param1, param2, ...]); var timeoutID = window.setTimeout(code, delay);
unde
timeoutID
este ID-ul numeric al execuției programate (timeout-ului), care poate fi folosit ca parametru pentruwindow.clearTimeout()
.func
este funcția care va fi apelată după durata specificată.code
(în sintaxa alternativă) este un șir de caractere (string) care conține fragmentul de cod ce va fi executat după durata specificată (nu este recomandată această sintaxă din aceleași motive ca și la eval())delay
este numărul de milisecunde (miimi de secundă) care trebuie să treacă înainte ca funcția să fie apelată. În realitate, această durată poate fi mai mare, vezi Notes mai jos.param1, param2
ș.a.m.d. sunt parametrii cu care va fi apelată funcțiafunc.
Notă: Internet Explorer 9 (și versiunile mai vechi) nu implementează transmiterea de parametri către funcție (param1, param2, ...). Pentru a putea face acest lucru trebuie folosit un polyfill (vezi secțiunea Callback arguments de mai jos).
Example
The following example sets up two simple buttons in a web page and hooks them to the setTimeout and clearTimeout routines. Pressing the first button will set a timeout which calls an alert dialog after 2 seconds and stores the timeout id for use by clearTimeout. You may optionally cancel this timeout by pressing on the second button.
HTML Content
<p>Live Example</p> <button onclick="delayedAlert();">Show an alert box after 2 seconds</button> <p></p> <button onclick="clearAlert();">Cancel alert before it happens</button>
JavaScript Content
var timeoutID; function delayedAlert() { timeoutID = window.setTimeout(slowAlert, 2000); } function slowAlert() { alert("That was really slow!"); } function clearAlert() { window.clearTimeout(timeoutID); }
See also clearTimeout()
example.
Callback arguments
If you need to pass an argument to your callback function, but need it to work in Internet Explorer, which doesn't support sending additional parameters (neither with setTimeout()
or setInterval()
) you can include this IE-specific compatibility code which will enable the HTML5 standard parameters passage functionality in that browser for both timers just by inserting it at the beginning of your scripts.
/*\ |*| |*| 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; }
Another possibility is to use an anonymous function to call your callback, but this solution is a bit more expensive. Example:
var intervalID = setTimeout(function() { myFunc("one", "two", "three"); }, 1000);
Yet another possibility is to use function's bind. Example:
setTimeout(function(arg1){}.bind(undefined, 10));
The "this
" problem
When you pass a method to setTimeout()
(or any other function, for that matter), it will be invoked with a wrong this
value. This problem is explained in detail in the JavaScript reference.
Explanation
Code executed by setTimeout()
is run in a separate execution context to the function from which it was called. As a consequence, the this
keyword for the called function will be set to the window
(or global
) object, it will not be the same as the this
value for the function that called setTimeout
. See the following example:
myArray = ["zero", "one", "two"]; myArray.myMethod = function (sProperty) { alert(arguments.length > 0 ? this[sProperty] : this); }; myArray.myMethod(); // prints "zero,one,two" myArray.myMethod(1); // prints "one" setTimeout(myArray.myMethod, 1000); // prints "[object Window]" after 1 second setTimeout(myArray.myMethod, 1500, "1"); // prints "undefined" after 1,5 seconds // let's try to pass the 'this' object setTimeout.call(myArray, myArray.myMethod, 2000); // error: "NS_ERROR_XPC_BAD_OP_ON_WN_PROTO: Illegal operation on WrappedNative prototype object" setTimeout.call(myArray, myArray.myMethod, 2500, 2); // same error
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); };
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.
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()
.
It's important to note that if the function or code snippet cannot be executed until the thread that called setTimeout()
has terminated.
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/ maximum delay and timeout nesting
Historically browsers implement setTimeout()
"clamping": successive setTimeout()
calls with delay
smaller than the "minimum delay" limit are forced to 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.
Browsers including Internet Explorer, Chrome, Safari and Firefox store the delay as a 32-bit signed Integer internally. This causes an Integer overflow when using delays larger than 2147483647, resulting in the timeout being executed immediately.
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 or earlier) | 4.0 | 4.0 | 1.0 |
Supports parameters for callback*1 | (Yes) | (Yes) | 10.0 | (Yes) | ? |
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 |
Supports parameters for callback*1 | ? | ? | ? | ? | ? | ? |
*1 Whether it supports the optional parameters when in its first form or not.
Specification
Part of DOM level 0, as specified in HTML5.