How do I pause execution in JavaScript?

The current article is taken from javascript.faqts
Contributors: ha mo, Daniel LaLiberte, Brent Boyer, Martin Honnen, mercury rising,

 

There is no true wait, sleep, or similar function in either the core JavaScript language or in client side JavaScript. Client side JavaScript however provides     setTimeout('js code here', delayInMilliseconds) which allows you to schedule execution of piece of script and setInterval('js code here', intervalInMilliseconds) which allows you to periodically execute a piece of script.

So if you wanted (pseudo code)

you would stuff the code into functions:

and call

 

If you wanted (pseudo code)

you code:  

Note that both setInterval and setTimeout return a timer id you can use to clear the scheduled execution e.g.

respectively

There are some major limitations with the solution given above. First, it makes your code more awkward to write and difficult to read. Even worse, the above technique will not work at all for certain situations.
For instance, consider a function that has state (i.e. local variables): it may be impossible to split it apart into 2 functions as called for above, since each half may need access to the full state. (It may be impossible to store the state in global variables instead of locals - say, if you are using the function recursively. Also, you cannot pass the state as args to the second function via setTimeout/setInterval because those functions only take Strings as the function specification.)

Below is a Javascript function that (from the callers perspective) is in fact a true pause:

 The main problem with this function is that it is not sleeping the underlying Javascript interpreter thread. Instead, it is worthlessly burning up a lot of CPU cycles. If you have a modern multithreaded browser, other processes (e.g. loading of a webpage) should still take place in other threads, but they will not finish as fast as they ought.

A sneaky way to get the effect of a true pause while not burning CPU cycles is to use a modal dialog with a timeout that closes the modal dialog window and resumes execution. A modal dialog pauses execution in the code that created it, but allows other threads to continue.

 

If you want a true and CPU efficient pause, you will need to use a real language. Your best choice is Java.

Client side JavaScript in NN4+ has direct access to Java objects via NN's LiveConnect technology, so your Javascript can simply call java.lang.Thread.sleep(timeInMilliSeconds)
CAUTION: if the JVM (Java Virtual Machine) has not yet started, there is an additional (several second) JVM start delay before your sleep call is executed. Subsequent calls will then delay the correct amount.

Officially, IE does not support Liveconnect. So, if you want a reliable cross browser solution, you can simply embed the above in a public method of a Java applet as follows: 

 

If the above is a member of the first Java applet in your html file, you may then invoke it from your Javascript like

WARNING: you should verify whether or not the browser you want to work in is actually intelligently multithreaded (i.e. runs the Javascript interpreter in it's own thread). A way that you can simply test this is to write a very large loop that doesn't do much and see whether or not the browser can still do things like respond to its GUI. Using this technique, it has been reported that NN appears to run the JS interpreter in the same thread as the browser GUI.