window.setInterval

最新推荐文章于 2022-04-01 10:28:38 发布
最新推荐文章于 2022-04-01 10:28:38 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： Web前端 文章标签： javascript

Summary

Calls a function or executes a code snippet repeatedly, with a fixed time delay between each call to that function.

Syntax

var intervalID = window.setInterval(func, delay[, param1, param2, ...]);
var intervalID = window.setInterval(code, delay);

where

  • intervalID is a unique interval ID you can pass to clearInterval().
  • func is the function you want to be called repeatedly.
  • code in the alternate syntax, is a string of code you want to be executed repeatedly (using this syntax is not recommended for the same reasons as using eval())
  • delay is the number of milliseconds (thousandths of a second) that the setInterval() function should wait before each call tofunc. As with setTimeout, there is a minimum delay enforced.

Note that passing additional parameters to the function in the first syntax does not work in Internet Explorer. If you want to enable this functionality on that browser you must use a compatibility code (see the Callback arguments paragraph).

Note: Prior to Gecko 13 (Firefox 13.0 / Thunderbird 13.0 / SeaMonkey 2.10), Gecko passed an extra parameter to the callback routine, indicating the "actual lateness" of the timeout in milliseconds. This non-standard parameter is no longer provided.

Examples

Example 1: Generic

1
var intervalID = window.setInterval(animate, 500);

Example 2: Alternating two colors

The following example will continue to call the flashtext() function once a second, until you clear the intervalID by clicking the Stop button.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<!DOCTYPE html>
< html >
< head >
< meta content = "text/html; charset=UTF-8" http-equiv = "Content-Type" />
< title >setInterval/clearInterval example</ title >
< script type = "text/javascript" >
var nIntervId;
  
function changeColor() {
   nIntervId = setInterval(flashText, 500);
}
  
function flashText() {
   var oElem = document.getElementById("my_box");
   oElem.style.color = oElem.style.color == "red" ? "blue" : "red";
}
  
function stopTextColor() {
   clearInterval(nIntervId);
}
</ script >
</ head >
  
< body onload = "changeColor();" >
< div id = "my_box" >
< p >Hello World</ p >
</ div >
< button onclick = "stopTextColor();" >Stop</ button >
</ body >
</ html >

Example 3: Simulating a typewriter

The following example will delete and re-type simulating a typewriter all the text content of the NodeList which match a specified group of selectors.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
<!doctype html>
< html >
< head >
< meta content = "text/html; charset=UTF-8" http-equiv = "Content-Type" />
< title >JavaScript Typewriter - MDN Example</ title >
< script type = "text/javascript" >
function Typewriter (sSelector, nRate) {
 
   function clean () {
     clearInterval(nIntervId);
     bTyping = false;
     bStart = true;
     oCurrent = null;
     aSheets.length = nIdx = 0;
   }
 
   function scroll (oSheet, nPos, bEraseAndStop) {
     if (!oSheet.hasOwnProperty("parts") || aMap.length < nPos ) { return true; }
 
     var oRel, bExit = false ;
 
     if (aMap.length === nPos) { aMap.push(0); }
 
     while (aMap[nPos] < oSheet.parts.length) {
       oRel = oSheet .parts[aMap[nPos]];
 
       scroll(oRel, nPos + 1, bEraseAndStop) ? aMap[nPos]++ : bExit = true ;
 
       if (bEraseAndStop && (oRel.ref.nodeType - 1 | 1) === 3 && oRel.ref.nodeValue) {
         bExit = true ;
         oCurrent = oRel .ref;
         sPart = oCurrent .nodeValue;
         oCurrent.nodeValue = "" ;
       }
 
       oSheet.ref.appendChild(oRel.ref);
       if (bExit) { return false; }
     }
 
     aMap.length--;
     return true;
   }
 
   function typewrite () {
     if (sPart.length === 0 && scroll(aSheets[nIdx], 0, true) && nIdx++ === aSheets.length - 1) { clean(); return; }
 
     oCurrent.nodeValue += sPart.charAt(0);
     sPart = sPart.slice(1);
   }
 
   function Sheet (oNode) {
     this.ref = oNode ;
     if (!oNode.hasChildNodes()) { return; }
     this.parts = Array .prototype.slice.call(oNode.childNodes);
 
     for (var nChild = 0 ; nChild < this.parts.length; nChild++) {
       oNode.removeChild(this.parts[nChild]);
       this.parts[nChild] = new Sheet(this.parts[nChild]);
     }
   }
 
   var
     nIntervId, oCurrent = null , bTyping = false , bStart = true ,
     nIdx = 0 , sPart = "" , aSheets = [], aMap = [];
 
   this.rate = nRate || 100;
  
   this.play = function () {
     if (bTyping) { return; }
     if (bStart) {
       var aItems = document .querySelectorAll(sSelector);
 
       if (aItems.length === 0) { return; }
       for (var nItem = 0 ; nItem < aItems.length; nItem++) {
         aSheets.push(new Sheet(aItems[nItem]));
         /* Uncomment the following line if you have previously hidden your elements via CSS: */
         // aItems[nItem] .style.visibility = "visible" ;
       }
 
       bStart = false ;
     }
 
     nIntervId = setInterval (typewrite, this.rate);
     bTyping = true ;
   };
  
   this.pause = function () {
     clearInterval(nIntervId);
     bTyping = false ;
   };
  
   this.terminate = function () {
     oCurrent.nodeValue += sPart;
     sPart = "" ;
     for (nIdx; nIdx < aSheets.length; scroll(aSheets[nIdx++], 0, false));
     clean();
   };
}
  
/* usage: */
var oTWExample1 = new Typewriter(/* elements: */ "#article, h1, #info, #copyleft", /* frame rate (optional): */ 15);
  
/* default frame rate is 100: */
var oTWExample2 = new Typewriter("#controls");
 
/* you can also change the frame rate value modifying the "rate" property; for example: */
// oTWExample2.rate = 150 ;
  
onload = function () {
   oTWExample1.play();
   oTWExample2.play();
};
</script>
< style type = "text/css" >
span.intLink, a, a:visited {
   cursor: pointer;
   color: #000000;
   text-decoration: underline;
}
  
#info {
   width: 180px;
   height: 150px;
   float: right;
   background-color: #eeeeff;
   padding: 4px;
   overflow: auto;
   font-size: 12px;
   margin: 4px;
   border-radius: 5px;
   /* visibility: hidden; */
}
</ style >
</ head >
  
< body >
 
< p id = "copyleft" style = "font-style: italic; font-size: 12px; text-align: center;" >CopyLeft 2012 by < a href = "https://developer.mozilla.org/" target = "_blank" >Mozilla Developer Network</ a ></ p >
< p id = "controls" style = "text-align: center;" >[&nbsp;< span class = "intLink" onclick = "oTWExample1.play();" >Play</ span > | < span class = "intLink" onclick = "oTWExample1.pause();" >Pause</ span > | < span class = "intLink" onclick = "oTWExample1.terminate();" >Terminate</ span >&nbsp;]</ p >
< div id = "info" >
Vivamus blandit massa ut metus mattis in fringilla lectus imperdiet. Proin ac ante a felis ornare vehicula. Fusce pellentesque lacus vitae eros convallis ut mollis magna pellentesque. Pellentesque placerat enim at lacus ultricies vitae facilisis nisi fringilla. In tincidunt tincidunt tincidunt.
</ div >
< h1 >JavaScript Typewriter</ h1 >
  
< div id = "article" >
< p >Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam ultrices dolor ac dolor imperdiet ullamcorper. Suspendisse quam libero, luctus auctor mollis sed, malesuada condimentum magna. Quisque in ante tellus, in placerat est. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Donec a mi magna, quis mattis dolor. Etiam sit amet ligula quis urna auctor imperdiet nec faucibus ante. Mauris vel consectetur dolor. Nunc eget elit eget velit pulvinar fringilla consectetur aliquam purus. Curabitur convallis, justo posuere porta egestas, velit erat ornare tortor, non viverra justo diam eget arcu. Phasellus adipiscing fermentum nibh ac commodo. Nam turpis nunc, suscipit a hendrerit vitae, volutpat non ipsum.</ p >
< form name = "myForm" >
< p >Phasellus ac nisl lorem: < input type = "text" name = "email" />< br />
< textarea name = "comment" style = "width: 400px; height: 200px;" >Nullam commodo suscipit lacus non aliquet. Phasellus ac nisl lorem, sed facilisis ligula. Nam cursus lobortis placerat. Sed dui nisi, elementum eu sodales ac, placerat sit amet mauris. Pellentesque dapibus tellus ut ipsum aliquam eu auctor dui vehicula. Quisque ultrices laoreet erat, at ultrices tortor sodales non. Sed venenatis luctus magna, ultricies ultricies nunc fringilla eget. Praesent scelerisque urna vitae nibh tristique varius consequat neque luctus. Integer ornare, erat a porta tempus, velit justo fermentum elit, a fermentum metus nisi eu ipsum. Vivamus eget augue vel dui viverra adipiscing congue ut massa. Praesent vitae eros erat, pulvinar laoreet magna. Maecenas vestibulum mollis nunc in posuere. Pellentesque sit amet metus a turpis lobortis tempor eu vel tortor. Cras sodales eleifend interdum.</ textarea ></ p >
< p >< input type = "submit" value = "Send" />
</ form >
< p >Duis lobortis sapien quis nisl luctus porttitor. In tempor semper libero, eu tincidunt dolor eleifend sit amet. Ut nec velit in dolor tincidunt rhoncus non non diam. Morbi auctor ornare orci, non euismod felis gravida nec. Curabitur elementum nisi a eros rutrum nec blandit diam placerat. Aenean tincidunt risus ut nisi consectetur cursus. Ut vitae quam elit. Donec dignissim est in quam tempor consequat. Aliquam aliquam diam non felis convallis suscipit. Nulla facilisi. Donec lacus risus, dignissim et fringilla et, egestas vel eros. Duis malesuada accumsan dui, at fringilla mauris bibStartum quis. Cras adipiscing ultricies fermentum. Praesent bibStartum condimentum feugiat.</ p >
< p >Nam faucibus, ligula eu fringilla pulvinar, lectus tellus iaculis nunc, vitae scelerisque metus leo non metus. Proin mattis lobortis lobortis. Quisque accumsan faucibus erat, vel varius tortor ultricies ac. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed nec libero nunc. Nullam tortor nunc, elementum a consectetur et, ultrices eu orci. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque a nisl eu sem vehicula egestas.</ p >
</ div >
</ body >
</ html >

View this demo in action. See also: clearInterval().

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 withsetTimeout() 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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/*\
|*|
|*|  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:

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

Yet another possibility is to use function's bind. Example:

1
var intervalID = setInterval( function (arg1) {}.bind(undefined, 10), 1000);

(Firefox 5.0 / Thunderbird 5.0 / SeaMonkey 2.2)

Inactive tabs

Starting in Gecko 5.0 (Firefox 5.0 / Thunderbird 5.0 / SeaMonkey 2.2), intervals are clamped to fire no more often than once per second in inactive tabs.

The "this" problem

When you pass a method to setInterval() (or any other function, for that matter), it will be invoked with a wrong this value. This problem is explained in detail in theJavaScript reference.

Explanation

Code executed by setInterval() 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 (which for praticity uses setTimeout() instead of setInterval() – the problem in fact is the same for both timers):

1
2
3
4
5
6
7
8
9
10
11
12
13
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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 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 non-standard-compliant polyfills also. See the  callback arguments paragraph for a  standard-compliant polyfill.

New feature test:

1
2
3
4
5
6
7
8
9
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

Another, more complex, solution for the this problem is the following little framework.

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.

A little framework

Sometimes a page uses dozens and dozens of animations. In such a condition is difficult and unnatural to keep track of all events started and then to stop them when appropriate through the clearTimeout() function. A possible approach to solve this problem is to nest all the informations needed by each animation to start, stop, etc. etc. in different objects and then to create a constructor for such class of objects in order to standardize and simplify the instantiation of them.
Here is a possible and minimalist example of such abstraction, which for this reason we named MiniDaemon.

Note: For a more complex but still modular modular version of it ( Daemon) see  JavaScript Daemons Management. This more complex version is nothing but a big and scalable collection of methods for the  Daemon constructor. But the  Daemon constructor itself is nothing but a clone of  MiniDaemon with an added support for  initand  onstart functions declarable during the instantiation of the  daemon.  So the MiniDaemon framework will remain the recommended way for simple animations, because  Daemon without its collection of methods is essentially a clone of it.

The architecture of this constructor explicitly avoids the use of closures. It also offers an alternative way to pass the this object to the callback function (seeThe "this" problem for details).

minidaemon.js:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/*\
|*|
|*|  MiniDaemon - Mozilla Developer Network - ver. 1.0 rev. 1
|*|
|*|  https://developer.mozilla.org/en-US/docs/DOM/window.setInterval
|*|
\*/
  
function MiniDaemon (oOwner, fTask, nRate, nLen) {
   if (!( this && this instanceof MiniDaemon)) { return ; }
   if (arguments.length < 2) { throw new TypeError( "MiniDaemon - not enough arguments" ); }
   if (oOwner) { this .owner = oOwner };
   this .task = fTask;
   if (isFinite(nRate) && nRate > 0) { this .rate = Math.floor(nRate); }
   if (nLen > 0) { this .length = Math.floor(nLen); }
}
  
MiniDaemon.prototype.owner = null ;
MiniDaemon.prototype.task = null ;
MiniDaemon.prototype.rate = 100;
MiniDaemon.prototype.length = Infinity;
  
   /* These properties should be read-only */
  
MiniDaemon.prototype.SESSION = -1;
MiniDaemon.prototype.INDEX = 0;
MiniDaemon.prototype.PAUSED = true ;
MiniDaemon.prototype.BACKW = true ;
  
   /* Global methods */
  
MiniDaemon.forceCall = function (oDmn) {
   oDmn.INDEX += oDmn.BACKW ? -1 : 1;
   if (oDmn.task.call(oDmn.owner, oDmn.INDEX, oDmn.length, oDmn.BACKW) === false || oDmn.isAtEnd()) { oDmn.pause(); return false ; }
   return true ;
};
  
   /* Instances methods */
  
MiniDaemon.prototype.isAtEnd = function () {
   return this .BACKW ? isFinite( this .length) && this .INDEX < 1 : this .INDEX + 1 > this .length;
};
  
MiniDaemon.prototype.synchronize = function () {
   if ( this .PAUSED) { return ; }
   clearInterval( this .SESSION);
   this .SESSION = setInterval(MiniDaemon.forceCall, this .rate, this );
};
  
MiniDaemon.prototype.pause = function () {
   clearInterval( this .SESSION);
   this .PAUSED = true ;
};
  
MiniDaemon.prototype.start = function (bReverse) {
   var bBackw = Boolean(bReverse);
   if ( this .BACKW === bBackw && ( this .isAtEnd() || ! this .PAUSED)) { return ; }
   this .BACKW = bBackw;
   this .PAUSED = false ;
   this .synchronize();
};
Note: This small framework utilises the  passage of arguments to the callback function. If you want to work on it with browsers which natively do not support this feature, use the polyfill proposed here.

Syntax

var myDaemon = new MiniDaemon(thisObject, callback[, rate[, length]]);

Description

Returns a JavaScript Object containing all informations needed by an animation (like the this object, the callback function, the length, the frame-rate).

Parameters
thisObject
The  this object on which will be called the  callback function. It can be an  object or  null.
callback
The function which will be invoked repeatedly.  It will be called with three parameters:  index (the iterative index of each invocation),  length (the number of total invocations assigned to the  daemon - finite or  Infinity) and  backwards (a boolean expressing whether the  index is increasing or decreasing). It will be something like  callback.call( thisObject,  index,  length,  backwards).  If the callback function returns a false value the daemon will be paused.
rate (optional)
The time lapse (in number of milliseconds) between each invocation. The default value is 100.
length (optional)
The total number of invocations. It can be a positive integer or  Infinity. The default value is  Infinity.
MiniDaemon instances properties
myDaemon.owner
The  this object on which is executed the daemon (read/write). It can be an  object or  null.
myDaemon.task
The function which will be repeatedly invoked (read/write). It will be called with three arguments:  index (the iterative index of each invocation),  length (the number of total invocations assigned to the daemon - finite or  Infinity) and backwards (a boolean expressing whether the  index is decreasing or not) – see above. If the myDaemon.task function returns a  false value the  daemon will be paused.
myDaemon.rate
The time lapse (in number of milliseconds) between each invocation (read/write).
myDaemon.length
The total number of invocations. It can be a positive integer or  Infinity (read/write).
MiniDaemon instances methods
myDaemon.isAtEnd()
Returns a boolean expressing whether the  daemon is at the start/end position or not.
myDaemon.synchronize()
Synchronize the timer of a started daemon with the time of its invocation.
myDaemon.pause()
Pauses the daemon.
myDaemon.start([reverse])
Starts the daemon forward ( index of each invocation increasing) or backwards ( index decreasing).
MiniDaemon global object methods
MiniDaemon.forceCall(minidaemon)
Forces a single callback to the  minidaemon.task function regardless of the fact that the end has been reached or not. In any case the internal  INDEX property will be increased/decreased (depending on the actual direction of the process).

Example usage:

your HTML page:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<!doctype html>
< html >
< head >
< meta http-equiv = "Content-Type" content = "text/html; charset=UTF-8" />
< title >MiniDaemin Example - MDN</ title >
< script type = "text/javascript" src = "minidaemon.js" ></ script >
< style type = "text/css" >
#sample_div {
   visibility: hidden;
}
</ style >
</ head >
 
< body >
< p >< input type = "button" onclick = "fadeInOut.start(false /* optional */);" value = "fade in" /> < input type = "button" onclick = "fadeInOut.start(true);" value = "fade out" > < input type = "button" onclick = "fadeInOut.pause();" value = "pause" /></ p >
< div id = "sample_div" >Some text here</ div >
 
< script type = "text/javascript" >
function opacity (nIndex, nLength, bBackwards) {
   this.style.opacity = nIndex / nLength;
   if (bBackwards ? nIndex === 0 : nIndex === 1) {
     this.style.visibility = bBackwards ? "hidden" : "visible";
   }
}
 
var fadeInOut = new MiniDaemon(document.getElementById("sample_div"), opacity, 300, 8);
</ script >
</ body >
</ html >

View this example in action

Notes

The setInterval() function is commonly used to set a delay for functions that are executed again and again, such as animations.

You can cancel the interval using window.clearInterval().

If you wish to have your function called once after the specified delay, use window.setTimeout().

Dangerous usage

If there is a possibility that your logic could take longer to execute than the interval time, it is recommended that you recursively call a named function usingwindow.setTimeout. For example, if using setInterval to poll a remote server every 5 seconds, network latency, an unresponsive server, and a host of other issues could prevent the request from completing in its alloted time. As such, you may find yourself with queued up XHR requests that won't necessarily return in order.

For such cases, a recursive setTimeout pattern is preferred:

1
2
3
4
5
6
7
8
9
10
( function loop(){
    setTimeout( function (){
 
       // logic here
 
       // recurse
       loop();
 
   }, 1000);
})();

In the above snippet, a named function loop is declared and is immediately executed. loop is recursively called inside setTimeout after the logic has completed executing. While this pattern does not guarantee execution on a fixed interval, it does guarantee that the previous interval has completed before recursing.

Browser compatibility

  • Desktop 
  • Mobile
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) ?

*1 Whether it supports the optional parameters when in its first form or not.


https://developer.mozilla.org/en-US/docs/DOM/window.setInterval

song_zheng
关注
专栏目录
window.setInterval(func,interval)定时器
猿码互联
06-08 489
window.setInterval()是JavaScript中的方法，用于在指定的时间间隔重复执行某个函数或代码块。它接受两个参数，第一个参数是要执行的函数或代码块，第二个参数是时间间隔（以毫秒为单位）。另外，可以使用匿名函数作为第一个参数来实现更复杂的功能。上述代码中，匿名函数内部获取当前时间并更新页面上id为"time"的元素的内容。上述代码将会在页面加载后每隔1秒打印一次"Hello, world!
Three.js动画实现：window.setInterval（），不采用tween库
dmyc1027的博客
06-24 395
通过window.setInterval创建动画，介绍三维轨迹创建。 首先说明，想要制作精密、复杂的动画效果，还是tween库来专业制作动画效果更好。在tween中有动画衔接chain等函数，能让动画之间的过渡更加平滑，也能避免一些多动画之间的冲突问题。而setInterval方法制作的动画与tween相比还是有很多不足，但是对于较为简单、单一的动画效果，setInterval方法也是可行的。而制作多个动画时的冲突问题，也可以通过及时清除setInterval对象、设置动画标志等方法解决。...
window.setInterval()和window.clearInterval()
iteye_14213的博客
06-22 160
window.setInterval() 功能：按照指定的周期（以毫秒计）来调用函数或计算表达式。 语法：setInterval(code,millisec) 解释：code：在定时时间到时要执行的JavaScript代码串。 millisec：设定的定时时间，用毫秒数表示。 返回值：定时器的ID值，可用于clearInterval()方法停止指定的定时器。 注：setInter...
Window setInterval() 方法
weixin_34284188的博客
08-03 146
        Window 对象 转自：https://www.w3cschool.cn/jsref/met-win-setinterval.html 定义和用法 setInterval() 方法可按照指定的周期（以毫秒计）来调用函数或计算表达式。 setInterval() 方法会不停地调用函数，直到 clearInterval() 被调用或窗口被关闭。由 setInterv...
精解window.setTimeout()window.setInterval()使用方式与参数传递问题！
01-19
在使用JScript的时候，我们有时需要间隔的执行一个方法，比如用来产生网页UI动画特效啥... window.setInterval(“intervalRun()”, n); window.setTimeout(delayRun, n); window.setInterval(intervalRun, n); 
window.clearInterval与window.setInterval的用法.
12-24
### window.clearInterval与window.setInterval的用法 在前端开发中，经常需要用到定时器来实现某些功能，例如计时器、轮播图等。而`window.setInterval`和`window.clearInterval`是JavaScript中用于处理定时任务的...
精解window.setTimeout()&window.setInterval()使用方式与参数传递问题！
10-30
在JavaScript编程中，window对象下的setTimeout和setInterval是两个非常重要的定时器方法，它们能够让某些函数延迟执行或者每隔一段时间重复执行。但是，由于这两个方法运行在一个由脚本宿主模拟出来的Timer线程中，...
Three.JS动画实现：window.setInterval（）
06-24
本节我们将深入探讨如何利用`window.setInterval()`函数不依赖于tween库来实现Three.js动画。 首先，我们要了解`setInterval()`函数的基本用法。`setInterval(function, milliseconds, param1, param2, ...)`这个...
window.setInterval()方法的定义和用法及offsetLeft与style.left的区别
09-03
`window.setInterval()` 是JavaScript中的一个核心方法，用于在指定的时间间隔内重复执行某段代码。这个方法在创建动画效果、执行定时任务或者持续更新页面内容等场景中非常常见。`setInterval()` 接受两个参数：要...
Window setInterval() 方法介绍
信阳农夫的专栏
04-24 1371
定义和用法 setInterval() 方法可按照指定的周期（以毫秒计）来调用函数或计算表达式。 setInterval() 方法会不停地调用函数，直到clearInterval()被调用或窗口被关闭。由 setInterval() 返回的 ID 值可用作 clearInterval() 方法的参数。 提示：1000 毫秒= 1 秒。 提示：如果你只想执行一次可以使用setTim...
window对象方法setInterval
weixin_43786904的博客
12-15 527
1，定时器 window对象有一个方法就是：window.setInterval接受两个参数(函数，间隔时间); 能够使每间隔时间，执行函数一次。习惯叫做定时器，按理来说应该是“间隔器”。 window.setInterval(function(){ console.log(“哈哈哈”); }, 1000); 也可以把window省略： setInterval(function(){ consol...
Jscript中window.setInterval和window.setTimeout区别
weixin_34262482的博客
01-31 124
[setTimeout] setTimeout(表达式,延时时间) 在执行时,是在载入后延迟指定时间后,去执行一次表达式,记住,次数是一次 用setTimeout实现的自动变化显示随机数的效果: &lt;html&gt; &lt;head&gt; &lt;script&gt; window.onload=sett; function sett() { document.body.innerHTML...
javascriptwindow对象setInterval()事件
why
10-12 1748
dom1.html --> //得到用户的操作,TRUE 或FALSE //var r=confirm("ni asf"); //打开一个窗口 //填入地址栏 //window.open("dom2.html"); // alert(r); // function fun() { //500毫秒后触发代码 //setTim
window.setInterval的用法与实例
热门推荐
苍月
01-04 4万+
window.setInterval() 功能：按照指定的周期（以毫秒计）来调用函数或计算表达式。 语法：setInterval(code,millisec)   解释：code：在定时时间到时要执行的JavaScript代码串。 millisec：设定的定时时间，用毫秒数表示。 返回值：定时器的ID值，可用于clearInterval()方法停止指定的定时器。 注：setInter
window.setInterval()启动轮询， window.clearInterval()无法结束
qq_34281886的博客
04-01 568
今天在作一个定时任务轮询时，使用按钮开启轮询任务，再次点击按钮设置关闭轮询任务，发现轮询不能被正常关闭，代码如下： methods:{ switchChange(val) { if (val) { this.time = window.setInterval(()=>{ console.log("轮询");//被轮询任务 }，2000) } ...
window.setInterval javascript 定时执行函数用法
胡杰的专栏
04-14 1654
Document自带的方法： 循环执行：var timeid = window.setInterval（“方法名或方法”，“延时”）; window.clearInterval(timeid); 定时执行：var tmid = window.setTimeout(“方法名或方法”, “延时”); window.clearTimeout(tmid); 举例说明： A.当要执行
Window setInterval() 方法详解，其中有的两个大坑：①当参数为code时，记得要用单引号括起来，否则代码只会执行一次。②单双引号歧义问题
Easylee的博客
05-16 708
目录 1_语法： 2_当参数为code时，两个易踩得坑： 3_四种正确的常见写法 4_总结 1_语法： setInterval(code, milliseconds); setInterval(function, milliseconds, param1, param2, ...) 参数 描述 code/function 必需。要调用一个代码串，也可以是一个函数。 milliseconds 必须。周期性执行或调用 code/function 之间的时间间隔，以毫秒计。
window.setinterval
最新发布
06-08
`window.setInterval()` 是 JavaScript 中的一个函数，用于按照指定的时间间隔重复执行指定的函数或代码块。它的语法如下： ```javascript window.setInterval(func, delay, param1, param2, ...) ``` 其中，`func...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值