Nested setTimeout calls are a more flexible alternative to setInterval, allowing us to set the time between executions more precisely.To cancel the execution, we should call clearTimeout/clearInterval with the value returned by setTimeout/setInterval.args) allow us to run the func once/regularly after delay milliseconds. That limitation comes from ancient times and many scripts rely on it, so it exists for historical reasons.įor server-side JavaScript, that limitation does not exist, and there exist other ways to schedule an immediate asynchronous job, like setImmediate for Node.js. The similar thing happens if we use setInterval instead of setTimeout: setInterval(f) runs f few times with zero-delay, and afterwards with 4+ ms delay. The 4+ ms obligatory delay between invocations comes into play. If (start + 100 < Date.now()) alert(times) // show the delays after 100msĮlse setTimeout(run) // else re-schedule SetIntervalAsync is a drop-in replacement of setInterval which shares the same API but is safe to use with non-reentrant, asynchronous (Date.now() - start) // remember delay from the previous call functions that are not designed to allow multiple executions at the same time. This is often a problem for non-reentrant functions ie. This may cause problems whenever the function takes longer to execute than the given interval, since it will be called again before the first execution has finished. SetInterval runs a given function repeateadly, once every fixed number of milliseconds. If you've ever had to deal with weird, subtle bugs as a consequence of using setInterval on asynchronous functions, or had to manually reimplement setInterval using setTimeout to prevent multiple executions of the same asynchronous function from overlapping, then this library is a drop-in replacement that will solve your issues. You can require a specific strategy for setIntervalAsync using CommonJS with the following snippets: When in doubt, the Dynamic strategy will likely suffice for most use cases, keeping the interval as close as possible to the desired one. You can choose whichever strategy works best for your application. If any execution takes longer than the desired interval, the next execution is delayed until the previous one has finished, and called immediately after this condition is reached.įixed: The given function is called repeatedly, guaranteeing a fixed delay of interval milliseconds between the end of one execution and the start of the following one. SetIntervalAsync provides two strategies which can be used to prevent a recurring function from executing more than once at any given moment:ĭynamic: If possible, the given function is called once every interval milliseconds. See Dynamic and Fixed setIntervalAsync for more details. You can choose whether you wish to use the Dynamic or Fixed strategies, which will either launch every execution as soon as possible or set a fixed delay between the end of one execution and the start of the next one. Since setIntervalAsync will guarantee that the function is never executed more than once at any given moment. SetIntervalAsync ( processQueue, 1000, queue )
0 kommentar(er)
