So I know that there are differences between setTimeout and setInterval, but consider these two code examples:
function myFunction(){
setTimeout('myFunction();', 100);
doSomething();
}
setTimeout('myFunction();', 100);
and
function myFunction(){
doSomething();
}
setInterval('myFunction();', 100);
Note that in the first example I call setTimeout at the begining of the function and then I doSomething. Therefore there is no extra delay from doSomething(). Does that mean that those two examples do exactly the same? Or is there even more subtle difference?
They're functionally about the same, but there are differences. One difference is in how browsers handle it if doSomething takes longer than the interval. With setInterval, at least some browsers will just skip the next interval if doSomething is still running. So if you use 100ms as you have, and doSomething takes 110 ms to run, the next run won't happen until 90ms later (of course, all of these times are approximate).
Another difference is that with the setTimeout, you'll get a new handle every time, whereas with setInterval you get one handle.
Another difference with your examples as given is that in the setTimeout example, you're firing up a JavaScript parser/compiler every time, whereas with setInterval you're only firing up the parser/compiler once. But this difference shouldn't matter, because you shouldn't be doing that at all — see below.
But subtleties aside, what you have there is functionally the same.
Side note: It's not best practice to pass strings into either setTimeout or setInterval. Instead, pass in a function reference:
// setTimeout
function myFunction(){
setTimeout(myFunction, 100);
doSomething();
}
setTimeout(myFunction, 100);
// setInterval
function myFunction(){
doSomething();
}
setInterval(myFunction, 100);
Passing in a string fires up a JavaScript parser and does the same thing as eval. It should be avoided whenever possible (and it's almost always possible).
T.J. Crowder explained the main differences, one other more subtle could appear (I change the time scale as it's easier to explain) :
Lets plot the difference with a very big timeout time : 1 Day. You call both methods at 00:00 on Day 1 and let it run for 1 year...
1 Year latter your method called by setInterval will execute at 00:00 + some milliseconds (because you may not be the only one asking for the processors to do things at this exact moment and the OS timers have granularity anyway).
But your setTimeout method will occur latter, maybe around 00:01 because each day it would have been called a little after the requested time and requested to be called the next day at the same time...
PS: It could also be called before the requested time in some cases but more often than not it run after :-D
Related
I created a var for a setInterval so I can stop it with clearInterval as such:
var repeat = setInterval(sayHello, 2000);
function sayHello() {
alert("Hello");
}
and here is the clearInterval:
clearInterval(repeat)
Now, in Firefox, once I ran this bit, if I want to know the value of "repeat", it returns the amount of time the interval ran. However, in Chrome, no matter how many times it ran, it always returns 1. Unless, I do the entire procedure over, it then return 2. It basically increments the instances as opposed to interval occurrences.
Anyone able to shed some light on this, how it works, and why...greatly appreciated!
All that is guaranteed is that setInterval will return a handle which can then be used by clearInterval. Other than that it is entirely up to the browser what that handle is and how it is used. Even if it seems to provide some information in one particular browser, that should not be relied on in any way as it will be subject to change.
To quote MDN:
The returned intervalID is a numeric, non-zero value which identifies the timer created by the call to setInterval(); this value can be passed to WindowOrWorkerGlobalScope.clearInterval() to cancel the timeout.
Don't expect it, or rely on it, to be anything else.
I am struggling to think of a use case in web-application development that needs to use setInterval.
The "danger" with setInterval being that it just queues up callbacks should one not complete within the allocated interval.
Furthermore, the behaviour of setInterval can be simulated with setTimeout or requestAnimationFrame without this "danger".
Given this, can someone provide me with a use-case where setInterval is the superior/more appropriate option?
Edit:
Thought I'd jot down my findings.
setInterval is an easy way to have something run at even-ish intervals. The intervals will mainly be quite accurate, but if the event loop is blocked, then they might be completely inaccurate.
var x = 0;
setInterval(function() {
waitBlocking(5000);
document.write(x++);
},100);
function waitBlocking(ms) {
var start = Date.now();
while((Date.now() - start) < ms) {}
}
As far as I can tell, setInterval is useful not if you want evenly spread interval callback invocations (see above), but if you want a convenient way of having a specific number of callback invocations in a period, spread across the timeframe as close as possible to when they should have run. Which seems like a rather narrow use case.
I'm sure I am missing something.
Edit 2:
This is basically the best approximation of a clock JS can achieve, so I guess setInterval is the "clock timer". Presumably this was useful in applications that needed simple clocks.
The use-case where setTnterval is appropriate is when you want to execute a function at an exact time. setInterval and setTimeout has subtitle differences. setInterval execute it function after delay starting from the time when the previose setInterval fired.
setInterval is also not reclusive so there is no fear of closures and memory leaks. More details can however be found here
Below is the code for a typical setInterval function
var intervalID = window.setInterval(myCallback, 500);
function myCallback() {
// Your code here
}
Where as to achieve the same function using setTimeout you will have to create a recursion which can create closures and then the problem of memory leaks comes in as demonstrated below.
function startTimer() {
var count = [1,2,3,4,5,6,7,8,9,0]
setTimeout(function() {
//do some stuff
count.push(100);//you have just create a closure
//and all the problems that is associated with it
startTimer();//this is where the recursion happens
}, 1000);
}
I run these code on my firefox, and the console gets 3 2 1, which means statements run before the former ones end.
function test(){
setTimeout(function(){console.log(1)},1000); //statement 0
setTimeout(function(){console.log(2)},500); //statement 1
}
test();
console.log(3); //statement 2
Is it a feature of javascript, and do I have to double-check a variable after assigning it some value? Cuz' it's way too complicated.
var a;
while(a!==get('some')){
a=get('some');
if(a===get('some')){
whatShouldBeRun();afterGetSome();
break;
}
}
That is exactly what you have asked it to do. Firstly, you ask it to kick off two statements to run some point in the future. Then you write "3". The first of those statements whose time it is to run then runs, and writes "2". Finally, the third of these runs and writes "1".
If you are using asynchronous processing - settimeout - then yes you need to handle this as with any other language. But then if you need it to run in order, don't tell it to run asynchronously.
To get them to run one after the other:
function test()
{
setTimeout(function()
{
console.log(1);setTimeout(function()
{
console.log(2);console.log(3)
},500)
},1000);
}
test();
[I might have some of this wrong]
The above code starts two timers, which will fire after 500 and 1000 milliseconds. console.log(3); will run first, with no delay; after 500 milliseconds, console.log(2) will be executed, and after another 500 milliseconds, comes console.log(1). This is the general general way how timers work in any language/framework which contains timers.
Sequential code runs in order, that is, subsequent lines of code are executed in series. Event-based systems, like web browsers and their JavaScript implementation, are different in that event handlers are executed only when the event happens. The code test(); console.log(3); is executed sequentially: two timers are started by calling setTimeout with the given intervals and event handlers, and 3 is written to the console. The "tick" event of the first timer comes after 500 ms, and its event handler function will write 2 to the console. The "tick" event of the second one comes after another 500 ms, and will write 1.
the .defer(5000) is causing a too much recursion error in JavaScript. How do I delay the execution by 5 seconds?
rotate: function () {
if (!paused) {
this.show(counter);
counter = counter + 1;
if (counter === Spire.Rotator.data.items.length) {
counter = 0;
}
Spire.Rotator.rotate().defer(5000);
//$.proxy(Spire.Rotator.rotate, Spire.Rotator).defer(delay);
}
}
This entire line:
Spire.Rotator.rotate().defer(5000);
is wrong. Because of the parentheses just after rotate, your function is immediately calling itself over and over again (infinite recursion). Removing the parentheses will fix that problem, but the code will probably not work. To fix the code, use the browser's window.setTimeout method, which accepts a function and a delay (in milliseconds) as two arguments:
setTimeout(function() {
Spire.Rotator.rotate();
}, 5000);
Why not just setTimeout(Spire.Rotator.rotate, 5000);? The reason is that this in that function would be window rather than Spire.Rotator. (There's plenty of information on the Internet about this.) Why not setTimeout("Spire.Rotator.rotate()", 5000);? That's a quite dated (deprecated) way to use the method that suffers from the same pitfalls of eval, a function that some JavaScript programmers including Douglas Crockford recommend not using.
Simply substitute this:
Spire.Rotator.rotate().defer(5000);
With this:
setTimeout(Spire.Rotator.rotate, 5000);
setTimeout() is javascript's native way of executing some Javascript code after a specified amount of time.
Actually, in your code, defer() never gets called. Assuming the rotate method you're defining is for the Spire.Rotator object what happens is:
rotate() calls rotate() calls rotate() calls rotate() .... [to infinity]
After infinity number of calls the return value of the infinitieth call will then call the defer method. But you have to wait for infinity calls to happen which takes eternity seconds to complete.
What you need is setTimeout().
I thought I would try and be clever and create a Wait function of my own (I realise there are other ways to do this). So I wrote:
var interval_id;
var countdowntimer = 0;
function Wait(wait_interval) {
countdowntimer = wait_interval;
interval_id = setInterval(function() {
--countdowntimer <=0 ? clearInterval(interval_id) : null;
}, 1000);
do {} while (countdowntimer >= 0);
}
// Wait a bit: 5 secs
Wait(5);
This all works, except for the infinite looping. Upon inspection, if I take the While loop out, the anonymous function is entered 5 times, as expected. So clearly the global variable countdowntimer is decremented.
However, if I check the value of countdowntimer, in the While loop, it never goes down. This is despite the fact that the anonymous function is being called whilst in the While loop!
Clearly, somehow, there are two values of countdowntimer floating around, but why?
EDIT
Ok, so I understand (now) that Javascript is single threaded. And that - sort of - answers my question. But, at which point in the processing of this single thread, does the so called asynchronous call using setInterval actually happen? Is it just between function calls? Surely not, what about functions that take a long time to execute?
There aren't two copies of the variable lying around. Javascript in web browsers is single threaded (unless you use the new web workers stuff). So the anonymous function never has the chance to run, because Wait is tying up the interpreter.
You can't use a busy-wait functions in browser-based Javascript; nothing else will ever happen (and they're a bad idea in most other environments, even where they're possible). You have to use callbacks instead. Here's a minimalist reworking of that:
var interval_id;
var countdowntimer = 0;
function Wait(wait_interval, callback) {
countdowntimer = wait_interval;
interval_id = setInterval(function() {
if (--countdowntimer <=0) {
clearInterval(interval_id);
interval_id = 0;
callback();
}
}, 1000);
}
// Wait a bit: 5 secs
Wait(5, function() {
alert("Done waiting");
});
// Any code here happens immediately, it doesn't wait for the callback
Edit Answering your follow-up:
But, at which point in the processing of this single thread, does the so called asynchronous call using setInterval actually happen? Is it just between function calls? Surely not, what about functions that take a long time to execute?
Pretty much, yeah — and so it's important that functions not be long-running. (Technically it's not even between function calls, in that if you have a function that calls three other functions, the interpreter can't do anything else while that (outer) function is running.) The interpreter essentially maintains a queue of functions it needs to execute. It starts starts by executing any global code (rather like a big function call). Then, when things happen (user input events, the time to call a callback scheduled via setTimeout is reached, etc.), the interpreter pushes the calls it needs to make onto the queue. It always processes the call at the front of the queue, and so things can stack up (like your setInterval calls, although setInterval is a bit special — it won't queue a subsequent callback if a previous one is still sitting in the queue waiting to be processed). So think in terms of when your code gets control and when it releases control (e.g., by returning). The interpreter can only do other things after you release control and before it gives it back to you again. And again, on some browsers (IE, for instance), that same thread is also used for painting the UI and such, so DOM insertions (for instance) won't show up until you release control back to the browser so it can get on with doing its painting.
When Javascript in web browsers, you really need to take an event-driven approach to designing and coding your solutions. The classic example is prompting the user for information. In a non-event-driven world, you could do this:
// Non-functional non-event-driven pseudo-example
askTheQuestion();
answer = readTheAnswer(); // Script pauses here
doSomethingWithAnswer(answer); // This doesn't happen until we have an answer
doSomethingElse();
That doesn't work in an event-driven world. Instead, you do this:
askTheQuestion();
setCallbackForQuestionAnsweredEvent(doSomethingWithAnswer);
// If we had code here, it would happen *immediately*,
// it wouldn't wait for the answer
So for instance, askTheQuestion might overlay a div on the page with fields prompting the user for various pieces of information with an "OK" button for them to click when they're done. setCallbackForQuestionAnswered would really be hooking the click event on the "OK" button. doSomethingWithAnswer would collect the information from the fields, remove or hide the div, and do something with the info.
Most Javascript implementation are single threaded, so when it is executing the while loop, it doesn't let anything else execute, so the interval never runs while the while is running, thus making an infinite loop.
There are many similar attempts to create a sleep/wait/pause function in javascript, but since most implementations are single threaded, it simply doesn't let you do anything else while sleeping(!).
The alternative way to make a delay is to write timeouts. They can postpone an execution of a chunk of code, but you have to break it in many functions. You can always inline functions so it makes it easier to follow (and to share variables within the same execution context).
There are also some libraries that adds some syntatic suggar to javascript making this more readable.
EDIT:
There's an excelent blog post by John Resig himself about How javascript timers work. He pretty much explains it in details. Hope it helps.
Actually, its pretty much guaranteed that the interval function will never run while the loop does as javascript is single-threaded.
There is a reason why no-one has made Wait before (and so many have tried); it simply cannot be done.
You will have to resort to braking up your function into bits and schedule these using setTimeout or setInterval.
//first part
...
setTimeout(function(){
//next part
}, 5000/*ms*/);
Depending on your needs this could (should) be implemented as a state machine.
Instead of using a global countdowntimer variable, why not just change the millisecond attribute on setInterval instead? Something like:
var waitId;
function Wait(waitSeconds)
{
waitId= setInterval(function(){clearInterval(waitId);}, waitSeconds * 1000);
}