What is the JavaScript version of sleep

Question

Is there a better way to engineer a sleep in JavaScript than the following pausecomp function  taken from here    function pausecomp millis        var date   new Date        var curDate   null      do   curDate   new Date          while curDate-date  lt  millis       This is not a duplicate of Sleep in JavaScript - delay between actions  I want a real sleep in the middle of a function  and not a delay before a piece of code executes

User · Answer

I personally like the simple   function sleep seconds       var waitUntil   new Date   getTime     seconds 1000      while new Date   getTime    lt  waitUntil  true      then   sleep 2      Sleeps for 2 seconds   I m using it all the time to create fake load time while creating scripts in P5js

User · Answer

In Livescript  which compiles to Javascript   you can do like the following    sleep    ms  func  - gt  set-timeout func  ms  console log  hello-1   lt - sleep 2000ms console log  hello-2   lt - sleep 2000ms console log  hello-3

User · Answer

For browsers  I agree that setTimeout and setInterval are the way to go   But for server-side code  it may require a blocking function  for example  so you can effectively have thread synchronization    If you re using node js and meteor  you may have run into the limitations of using setTimeout in a fiber  Here is the code for server-side sleep   var Fiber   require  fibers     function sleep ms        var fiber   Fiber current      setTimeout function             fiber run           ms       Fiber yield       Fiber function         console log  wait        new Date       sleep 1000       console log  ok        new Date      run    console log  back in main      See  https   github com laverdet node-fibers sleep

User · Answer

I know the question is about sleep  and clearly the answer is that it isn t possible  I think a common want for sleep is to handle asynchronous tasks in order  I know I have had to deal with it for sure   Many cases may be able to use promises  AJAX requests common use   They let you do asynchronous things in a synchronous manner   There is also handling for success failure  and they can be chained    They part of ECMAScript 6  so browser support isn t all there yet  mainly  IE does not support them   There is also library called Q for doing promises   References  http   www html5rocks com en tutorials es6 promises   https   github com jakearchibald es6-promise readme  Shim for older  or IE browsers

User · Answer

If you re using jQuery  someone actually created a  delay  plugin that s nothing more than a wrapper for setTimeout      Delay Plugin for jQuery    - http   www evanbot com    -    2008 Evan Byrne  jQuery fn delay   function time func       this each function            setTimeout func time                return this       You can then just use it in a row of function calls as expected       warning    addClass  highlight    delay 1000   removeClass  highlight

User · Answer

If you want to sleep an anonymous function like one you ve created as a handler  I recommend the following   function     if   wait condition            setTimeout arguments callee  100    comma-separated arguments here             rest of function     This code says  If the wait condition has not yet been satisfied  call this function again with these arguments   I ve used this method to pass in the same arguments to my handlers  effectively making this code a non-polling sleep    which only works at the start of your function

User · Answer

To summarize  like it has been said in previous answers    There is no built-in sleep function in JavaScript  You should use setTimeout or setInterval to achieve a similar effect   If you really wanted to  you could simulate sleep functionality with a for loop such as the one shown in the original question  but that would make your CPU work like crazy  Inside a Web Worker an alternative solution would be to make a synchronous XMLHttpRequest to a non-responsive IP and set a proper timeout  This would avoid the CPU utilization problem  Here s a code example    x000D   x000D     Works only inside a web worker x000D   x000D  function sleep milliseconds    x000D   var req   new XMLHttpRequest    x000D   req open  GET    http   192 0 2 0    false   x000D   req timeout   milliseconds  x000D   try   x000D    req send    x000D     catch  ex    x000D     x000D     x000D    x000D   x000D  console log  Sleeping for 1 second       x000D  sleep 1000   x000D  console log  Slept     x000D   x000D  console log  Sleeping for 5 seconds      x000D  sleep 5000   x000D  console log  Slept     x000D   x000D   x000D

User · Answer

The problem with most solutions here is that they rewind the stack  This can be a big problem in some cases In this example I show how to use iterators in different way to simulate real sleep  In this example the generator is calling  it s own next   so once it s going  it s on his own   var h a    h next   value r h    that s how U run it  best I came up with    sleep without breaking stack     function  a        var obj           console log  going to sleep    2s        setTimeout function   obj r next     2000         yield obj       console log  woke up        console log  going to sleep no 2    2s       setTimeout function   obj r next     2000         yield obj        console log  woke up        console log  going to sleep no 3    2s         setTimeout function   obj r next     2000        yield obj       console log  done

User · Answer

First   Define a function you want to execute like this   function alertWorld      alert  Hello World        Then schedule its execution with the setTimeout method   setTimeout alertWorld 1000    Note two things   the second argument is time in miliseconds as a first argument you have to pass just the name  reference  of the function  without the parenthesis

User · Answer

In JavaScript  I rewrite every function so that it can end as soon as possible  You want the browser back in control so it can make your DOM changes   Every time I ve wanted a sleep in the middle of my function  I refactored to use a setTimeout     Edit  The infamous sleep  or delay  function within any language is much debated   Some will say that there should always be a signal or callback to fire a given functionality  others will argue that sometimes an arbitrary moment of delay is useful   I say that to each their own and one rule can never dictate anything in this industry   Writing a sleep function is simple and made even more usable with JavaScript Promises      sleep time expects milliseconds function sleep  time      return new Promise  resolve    gt  setTimeout resolve  time          Usage  sleep 500  then      gt           Do something after the sleep

User · Answer

A good alternative in some situations is to display a top-level message panel to stop user interaction  and then hide it again when you get the result you re waiting for  asynchronously   That allows the browser to get on with background tasks  but pauses the workflow until you ve got your result back

User · Answer

A function to sleep  using a synchronous call to let the OS do it  Use any OS sleep command you like  It is not busy waiting in the sense of using CPU time   I chose ping on a non-existant address   const cp   require  child process     function sleep ms         try cp execSync  ping 192 0 2 0 -n 1 -w   ms        catch err        A test to verify it works  console log Date now     console log Date now     sleep 10000   console log Date now     console log Date now       And some test results   1491575275136 1491575275157    and after 10 seconds   1491575285075 1491575285076

User · Answer

To keep the main thread busy for some milliseconds   function wait ms      const start   performance now      while performance now   - start  lt  ms

User · Answer

Adding my two bits  I needed a busy-wait for testing purposes  I didn t want to split the code as that would be a lot of work  so a simple for did it for me    for  var i 0 i lt 1000000 i                                waiting       I don t see any downside in doing this and it did the trick for me

User · Answer

2019 Update using Atomics wait  Should work in Node 9 3 or higher   I needed a pretty accurate timer in Node js and it works great for that  However it seems like there is extremely limited support in browsers    x000D   x000D  let ms   10000  x000D  Atomics wait new Int32Array new SharedArrayBuffer 4    0  0  ms   x000D   x000D   x000D    Ran a few 10 second timer benchmarks   With setTimeout I get a error of up to 7000 microseconds   7ms   With Atomics my error seems to stay under 600 microseconds   0 6ms   2020 Update  In Summary   function sleep millis      need help of a server-side page   let netMillis Math max millis-5 0     assuming 5ms overhead   let xhr new XMLHttpRequest      xhr open  GET    sleep jsp millis   netMillis   amp rand   Math random    false     try      xhr send       catch e         function sleepAsync millis      use only in async function   let netMillis Math max millis-1 0      assuming 1ms overhead   return new Promise  resolve   gt       setTimeout resolve  netMillis           function sleepSync millis      use only in worker thread  currently Chrome-only   Atomics wait new Int32Array new SharedArrayBuffer 4    0  0  millis      function sleepTest      console time  sleep      sleep 1000     console timeEnd  sleep      async function sleepAsyncTest      console time  sleepAsync      await sleepAsync 1000     console timeEnd  sleepAsync      function sleepSyncTest       let source    sleepSync toString        console time  sleepSync        sleepSync 1000       console timeEnd  sleepSync        let src  data text javascript   encodeURIComponent source     console log src     var worker new Worker src       of which the a server-side page  e g  sleep jsp  looks like   lt   try    Thread sleep Long parseLong request getParameter  millis       catch InterruptedException e      gt

User · Answer

If you like an advise to not loss performance   setTimeout is your expected sleep    However   if you wanna a syntax where code  is  divided in middle  by sleep  we can do      sleep function tm fn      window setTimeout fn tm       then   perpare functions as following     var fnBeforeSleep function        All codes before sleep       var fnAfterSleep function        All codes after sleep        Then    fnBeforeSleep    sleep 2000  fnAfterSleep     YEP   syntactically It is very close to    fnBeforeSleep    sleep 2000    fnAfterSleep

User · Answer

This is really not a good idea  doing something like this would cause the entire page to freeze up while the system waited for your function to return

User · Answer

x000D   x000D    await new Promise resolve   gt  setTimeout resolve  2000    x000D   x000D   x000D    make sure your calling function is async   verified and working fine

User · Answer

Code taken from this link will not freeze comp  But it works only on ff          Netscape compatible WaitForDelay function     You can use it as an alternative to Thread Sleep   in any major programming language    that support it while JavaScript it self doesn t have any built-in function to do such a thing     parameters      Number  delay in millisecond     function nsWaitForDelay delay                   Just uncomment this code if you re building an extention for Firefox         Since FF3  we ll have to ask for user permission to execute XPCOM objects              netscape security PrivilegeManager enablePrivilege  UniversalXPConnect            Get the current thread      var thread   Components classes   mozilla org thread-manager 1   getService Components interfaces nsIThreadManager  currentThread          Create an inner property to be used later as a notifier      this delayed   true          Call JavaScript setTimeout function         to execute this delayed   false         after it finish               setTimeout  this delayed   false    delay                   Keep looping until this delayed   false             while  this delayed                           This code will not freeze your browser as it s documented in here             https   developer mozilla org en Code snippets Threads Waiting for a background task to complete                     thread processNextEvent true

User · Answer

I would encapsulate setTimeOut in a Promise for code consistency with other asynchronous tasks   Demo in Fiddle  function sleep ms        return new Promise function resolve  reject                    setTimeout function     resolve       ms                            Used like that    sleep 2000  then function            Do something       It is easy to remember syntax if you used to use Promises

User · Answer

I prefer this functional style one liner sleep function  const sleep    ms    gt  new Promise  res    gt  setTimeout res  ms  ms        usage async function main       console log  quot before quot      const t   await sleep 10 000      10 sec      console log  quot after  quot    t     main

User · Answer

I use the multithread HTML5 Worker which will be able to abort an synchronous XMLHttpRequest pointing to an unresponsive URL  This does not block the browser   https   gist github com el-gringo 6990785

User · Answer

If you re on node js  you can have a look at fibers     a native C extension to node  a kinda-multi-threading simulation   It allows you to do a real sleep in a way which is blocking execution in a fiber  but it s non-blocking in the main thread and other fibers   Here s an example fresh from their own readme      sleep js  var Fiber   require  fibers     function sleep ms        var fiber   Fiber current      setTimeout function             fiber run           ms       Fiber yield       Fiber function         console log  wait        new Date       sleep 1000       console log  ok        new Date      run    console log  back in main          and the results are     node sleep js wait    Fri Jan 21 2011 22 42 04 GMT 0900  JST  back in main ok    Fri Jan 21 2011 22 42 05 GMT 0900  JST

User · Answer

I have had this question for a long time and the answer I needed was not exactly what has been provided here  This wait function causes a synchronous wait that does not tie up the cpu  waitForIt makes an ajax request to anywhere and sets the async flag to false  waitF does the same with a frame and waitD does the same with a div  Ajax takes about 100 ms  frame is about 25  and div is about 1  The wait function leverages all of these depending on how much time you give it  If it didn t wait long enough then do it again  I need this when dealing with multiple asynchronous loading elements  Basically for  wait until this element exists   You can play with it here https   jsfiddle net h2vm29ue  It just leverages the things that the browser naturally waits for  Longer version https   jsfiddle net 5cov1p0z 32  is more precise    function waitForIt          var start   new Date         var xhttp   new XMLHttpRequest         xhttp onreadystatechange   function              if  this readyState    4  amp  amp  this status    200                  doesn t matter                         xhttp open  GET    WaitForIt   false        xhttp send         var end   new Date               function waitF          var start   new Date         var ifram   document createElement  iframe         ifram id    ifram        ifram src            var div   document createElement  div         div id    timer        document body appendChild div        document getElementById  timer   appendChild ifram        document getElementById  timer   removeChild ifram        document body removeChild div        var end   new Date         return  end - start         function waitD          var start   new Date         var div   document createElement  div         div id    timer        document body appendChild div        div click         document body removeChild div        var end   new Date         return  end - start        function wait time         var start   new Date         var end   new Date         while   end - start  lt  time               if   time -  end - start    gt   200                 waitForIt               else                if   time -  end - start    gt   50                     waitF                   else                    waitD                                        end   new Date                return  end - start

User · Answer

With await support and bluebird promise   await bluebird delay 1000    This will work like a synchronous sleep 1  of c language  My favorite solution

User · Answer

You can use a closure call setTimeout   with incrementally larger values   var items     item1    item2    item3     function functionToExecute item      console log  function executed for item      item        each items  function  index  item      var timeoutValue   index   2000    setTimeout function         console log  waited     timeoutValue     milliseconds        functionToExecute item        timeoutValue         Result   waited 0 milliseconds function executed for item  item1 waited 2000 milliseconds function executed for item  item2 waited 4000 milliseconds function executed for item  item3

User · Answer

Only for debug dev   I post this if it s useful to someone Interesting stuff  in Firebug    amp  probably other js consoles    nothing happen after hitting enter  only after the sleep duration specified       function sleepFor  sleepDuration        var now   new Date   getTime        while new Date   getTime    lt  now   sleepDuration      do nothing          Example of use   x000D   x000D  function sleepFor  sleepDuration      var now   new Date   getTime      while new Date   getTime    lt  now   sleepDuration      do nothing          function sleepThenAct      sleepFor 2000     console log  hello js sleep         sleepThenAct   x000D   x000D   x000D

User · Answer

Try this simple javascript function   function sleep milliseconds        var  return   false      if  typeof importScripts     function             var sleep xhr   function  milliseconds                try                   var xhr   new XMLHttpRequest                    xhr open  GET    http   128 0 0 1      Math random     100000  toFixed 0         false                   xhr timeout   milliseconds                  xhr send                  catch  E                       Nothing to do                                     milliseconds   milliseconds   0          if  milliseconds  gt  0                var start   Date now                while  Date now    lt  start   milliseconds                    sleep xhr  start   milliseconds  - Date now                                return   Date now   - start                      return  return      Note  This function only works on web workers

User · Answer

If you really want to pause a script  you can do this   var milliseconds  var pretime  var stage   function step time     switch stage       case 0          Code before the pause        pretime time        milliseconds XXX        stage 1        break      case 1          Code that is looped through while paused        if time-pretime  gt   milliseconds             Code after the pause          pretime time          milliseconds XXX          stage 2                break      case 2          Code that is looped through while paused        if time-pretime  gt   milliseconds             Code after the pause          pretime time          milliseconds XXX          stage 3                break      case 3          Etc           Window requestAnimationFrame step     step      This is probably exactly what you want if you use a loop anyway  and you can change it in ways so that you have pseudo-multi-threading  where you have some functions waiting a while and others running normally  I use this all the time for pure-JS games

User · Answer

Better solution to make things look like what most people want is to use an anonymous function   alert  start    var a    foo     lots of code setTimeout function       Beginning of code that should run AFTER the timeout     alert a         lots more code   5000       put the timeout here   This is probably the closest you ll get to something that simply does what you want   Note  if you need multiple sleeps this can get ugly in a hurry and you might actually need to rethink your design

User · Answer

Or just create this   function yourFunction          do something    setInterval myFunc   1000        do something else     function myFunc       return      this will just wait the interval specified and call the function which will just do nothing

User · Answer

var waitTillSomethingHappens   function          if somethingHappened    1                    alert  Something Happened get out of sleep                else             setTimeout waitTillSomethingHappens 1000

User · Answer

I know this is a bit of an old question  but if  like me  you re using Javascript with Rhino  you can use     try     java lang Thread sleep timeInMilliseconds     catch  e              This will happen if the sleep is woken up - you might want to check      if enough time has passed and sleep again if not - depending on how      important the sleep time is to you

User · Answer

Another possible way is   var  timer  clearTimeout  timer    timer   setTimeout function            Your code    1000      Delay for 1 s

User · Answer

Since Node 7 6  you can combine the  promisify function from the utils module with setTimeout    const sleep   require  util   promisify setTimeout    General Usage  async function main         console time  Slept for       await sleep 3000      console timeEnd  Slept for      main     Question Usage  async function asyncGenerator         while  goOn          var fileList   await listFiles nextPageToken         await sleep 3000        var parents   await requestParents fileList

User · Answer

I m sure there is a million ways to do this one better  but I thought I would give it a try by creating an object      execute code consecutively with delays  blocking non-blocking internally  function timed functions      this myfuncs       this myfuncs delays          mirrors keys of myfuncs -- values stored are custom delays  or -1 for use default this myfuncs count   0     increment by 1 whenever we add a function this myfuncs prev     -1     previous index in array this myfuncs cur      0     current index in array this myfuncs next    0     next index in array this delay cur       0     current delay in ms this delay default   0     default delay in ms this loop   false          will this object continue to execute when at end of myfuncs array  this finished   false      are we there yet  this blocking   true       wait till code completes before firing timer  this destroy   false        lt advanced gt  destroy self when finished   this next cycle   function     var that    this  var mytimer   this delay default   if this myfuncs cur  gt  -1  if this myfuncs delays this myfuncs cur   gt  -1  mytimer   this myfuncs delays this myfuncs cur    console log  fnc     this myfuncs cur   console log  timer     mytimer   console log  custom delay     this myfuncs delays this myfuncs cur    setTimeout function        times up  next cycle    that cycle         mytimer      this cycle   function         now check how far we are along our queue   is this the last function  if this myfuncs next   1  gt  this myfuncs count    if this loop    console log  looping      this myfuncs next   0    else this finished   true         first check if object isn t finished if this finished  return false      HANDLE NON BLOCKING    if this blocking    true     blocking disabled   console log  NOT BLOCKING    this next cycle           set prev   current  and current to next  and next to new next this myfuncs prev   this myfuncs cur  this myfuncs cur    this myfuncs next  this myfuncs next         execute current slot this myfuncs this myfuncs cur            HANDLE BLOCKING if this blocking    true      blocking enabled   console log  BLOCKING    this next cycle          return true         adders  this add     that this   fnc  function aFunction        add to the function array var cur key   this that myfuncs count    this that myfuncs cur key    aFunction     add to the delay reference array this that myfuncs delays cur key    -1          end  this add     setters this set     that this    delay           function ms         var cur key   this that myfuncs count - 1     this will handle the custom delay array this that myfunc delays    add a custom delay to your function container  console log  setting custom delay  key     cur key     msecs      ms   if cur key  gt  -1     this that myfuncs delays cur key    ms         so now we create an entry on the delay variable       delay cur       function ms       this that delay cur   ms             delay default   function ms       this that delay default   ms             loop on           function            this that loop   true      loop off          function            this that loop   false     blocking on       function            this that blocking   true      blocking off      function            this that blocking   false      finished            function aBool    this that finished   true          end  this set          setters this get     that this    delay default  function     return this that delay default     delay cur      function     return this that delay cur          end  this get            end   function timed functions     and use like               BEGIN    TEST              initialize var fncTimer   new timed functions      set some defaults fncTimer set delay default 1000   fncTimer set blocking on       fncTimer set loop on       fncTimer set loop off         BEGIN    ADD FUNCTIONS  they will fire off in order  fncTimer add fnc function         console log  plan a  2 secs         fncTimer set delay 2000      set custom delay for previously added function  fncTimer add fnc function         console log  hello world  delay 3 seconds         fncTimer set delay 3000    fncTimer add fnc function         console log  wait 4 seconds           fncTimer set delay 4000    fncTimer add fnc function         console log  wait 2 seconds        fncTimer set delay 2000    fncTimer add fnc function         console log  finished            END    ADD FUNCTIONS      NOW RUN fncTimer cycle       begin execution             END    TEST

User · Answer

For the love of  DEITY please do not make a busy-wait sleep function   setTimeout and setInterval do everything you need    x000D   x000D  var showHide   document getElementById  showHide    x000D  setInterval      gt    x000D      showHide style visibility    initial   x000D      setTimeout      gt    x000D          showHide style visibility    hidden  x000D         1000   x000D        x000D     2000      x000D   lt div id  showHide  gt Hello  Goodbye  lt  div gt  x000D   x000D   x000D    Every two second interval hide text for one second  This shows how to use setInterval and setTimeout to show and hide text each second

User · Answer

An old question from 2009   Now in 2015 a new solution is possible with generators defined in ECMAscript 2015 aka ES6   It was approved in June  but it was implemented in Firefox and Chrome before   Now a sleep function can be made non-busy  non-blocking and nested inside loops and sub-functions without freezing the browser   Only pure JavaScript is needed  no libraries or frameworks   The program below shows how sleep   and runSleepyTask   can be made   The sleep   function is only a yield statement   It is so simple that it is actually easier to write the yield statement directly in stead of calling sleep    but then there would be no sleep-word  -   The yield returns a time value to the next   method inside wakeup   and waits   The actual  sleeping  is done in wakeup   using the good old setTimeout     At callback the the next   method triggers the yield statement to continue  and the  magic  of yield is that all the local variables and the whole call-stack around it is still intact   Functions that use sleep   or yield must be defined as generators   Easy done by adding an asterix to the keyword function    To execute a generator is a bit trickier   When invoked with the keyword new the generator returns an object that has the next   method  but the body of the generator is not executed  the keyword new is optional and makes no difference    The next   method triggers execution of the generator body until it encounters a yield   The wrapper function runSleepyTask   starts up the ping-pong  next   waits for a yield  and yield waits a next     Another way to invoke a generator is with keyword yield   here it works like a simple function call  but it also includes the ability to yield back to next     This is all demonstrated by the example drawTree     It draws a tree with leaves on a rotating 3D scene   A tree is drawn as a trunk with 3 parts at the top in different directions   Each part is then drawn as another but smaller tree by calling drawTree   recursively after a short sleep   A very small tree is drawn as only a leaf   Each leaf has its own life in a separate task started with runSleepyTask     It is born  grows  sits  fades  falls and dies in growLeaf     The speed is controlled with sleep     This demonstrates how easy multitasking can be done    x000D   x000D  function  sleep milliseconds   yield milliseconds   x000D   x000D  function runSleepyTask task    x000D       function wakeup     x000D          var result   task next    x000D          if   result done  setTimeout wakeup  result value   x000D           x000D    x000D                   written by Ole Middelboe                                x000D   x000D  pen3D  setup3D    x000D  var taskObject   new drawTree pen3D center  5   x000D  runSleepyTask taskObject   x000D   x000D  function  drawTree root3D  size    x000D      if  size  lt  2  runSleepyTask new growLeaf root3D   x000D      else   x000D          pen3D drawTrunk root3D  size   x000D          for  var p of  1  3  5     x000D              var part3D   new pen3D Thing  x000D              root3D add part3D   x000D              part3D move size  turn p  tilt 1-p 20   x000D              yield  sleep 50   x000D              yield  drawTree part3D   0 7 p 40  size   x000D            x000D        x000D    x000D   x000D  function  growLeaf stem3D    x000D      var leaf3D   pen3D drawLeaf stem3D   x000D      for  var s 0 s   lt 15    yield  sleep 100   leaf3D scale multiplyScalar 1 1   x000D      yield  sleep  1000   9000 Math random      x000D      for  var c 0 c   lt 30    yield  sleep 200   leaf3D skin color setRGB c 30  1-c 40  0   x000D      for  var m 0 m   lt 90    yield  sleep  50   leaf3D turn 0 4  tilt 0 3  move 2   x000D      leaf3D visible   false  x000D    x000D                                                                          x000D   x000D  function setup3D     x000D      var scene  camera  renderer  diretionalLight  pen3D  x000D   x000D      scene   new THREE Scene    x000D      camera   new THREE PerspectiveCamera 75   x000D          window innerWidth   window innerHeight  0 1  1000   x000D      camera position set 0  15  20   x000D      renderer   new THREE WebGLRenderer   alpha  true  antialias  true     x000D      renderer setSize window innerWidth  window innerHeight   x000D      document body appendChild renderer domElement   x000D       x000D      directionalLight   new THREE DirectionalLight 0xffffaa  0 7   x000D      directionalLight position set -1  2  1   x000D      scene add directionalLight   x000D      scene add new THREE AmbientLight 0x9999ff    x000D         x000D       function render     x000D          requestAnimationFrame render   x000D             renderer setSize  window innerWidth  window innerHeight    x000D          scene rotateY 10 60 60   x000D          renderer render scene  camera   x000D            x000D       x000D      window addEventListener  x000D           resize   x000D          function    x000D              renderer setSize  window innerWidth  window innerHeight    x000D              camera aspect   window innerWidth   window innerHeight  x000D              camera updateProjectionMatrix    x000D             x000D         false x000D         x000D       x000D      pen3D     x000D          drawTrunk  function root  size    x000D                 root skin   skin 0 5  0 3  0 2   x000D              root add new THREE Mesh new THREE CylinderGeometry size 12  size 10  size  16    x000D                  root skin  translateY size 2    x000D              root add new THREE Mesh new THREE SphereGeometry size 12  16    x000D                  root skin  translateY size    x000D              return root  x000D             x000D           x000D          drawLeaf  function stem    x000D              stem skin color setRGB 0  1  0   x000D              stem add new THREE Mesh new THREE CylinderGeometry 0  0 02  0 6    x000D                  stem skin   rotateX 0 3  translateY 0 3    x000D              stem add new THREE Mesh new THREE CircleGeometry 0 2    x000D                  stem skin   rotateX 0 3  translateY 0 4    x000D              return stem  x000D             x000D           x000D          Thing  function     x000D              THREE Object3D call this   x000D              this skin   new THREE MeshLambertMaterial   x000D                  color  new THREE Color 0 5  0 3  0 2   x000D                  vertexColors  THREE FaceColors  x000D                  side  THREE DoubleSide x000D                 x000D            x000D         x000D   x000D      pen3D Thing prototype   Object create THREE Object3D prototype   x000D      pen3D Thing prototype tilt   pen3D Thing prototype rotateX  x000D      pen3D Thing prototype turn   pen3D Thing prototype rotateY  x000D      pen3D Thing prototype move   pen3D Thing prototype translateY  x000D       x000D      pen3D center   new pen3D Thing  x000D      scene add pen3D center   x000D       x000D      return pen3D  x000D    x000D   lt script src  https   cdnjs cloudflare com ajax libs three js r71 three min js  gt  lt  script gt  x000D   x000D   x000D    The 3D stuff is hidden inside setup3D   and is only included to make it less boring than console log     Angels are measured in radians by the way   Tested to work in Firefox and Chrome   Not implemented in Internet Explore and iOS  iPads    Try to run it yourself   After another pass of the answers I found  that Gabriel Ratener made a similar answer a year ago  https   stackoverflow com a 24401317 5032384

User · Answer

I navigate the solution for a day but still thinking how to maintain the chainability in using callback  Everyone is familiar with the traditional programming style which running the code line by line in synchronised way  SetTimeout uses a callback so the next line does not wait for it to complete  This let me think how to make it  sync   so as to make a  sleep  function   Beginning with a simple coroutine   function coroutine         console log  coroutine-1 start        sleepFor 3000     sleep for 3 seconds here     console log  coroutine-2 complete        I want to sleep 3 seconds in the middle but don t want to dominate the whole flow  so the coroutine must be executed by another thread  I consider the Unity YieldInstruction  and modify the coroutine in the following   function coroutine1         this a   100      console log  coroutine1-1 start        return sleepFor 3000  yield     sleep for 3 seconds here     console log  coroutine1-2 complete        this a       var c1   new coroutine1      Declare the sleepFor prototype   sleepFor   function ms        var caller   arguments callee caller toString        var funcArgs         s S       gi exec caller  1       var args   arguments callee caller arguments      var funcBody   caller replace     s S   sleepFor  s S   yield     s     g          var context   this      setTimeout function             new Function funcArgs  funcBody  apply context  args          ms       return this      After run the coroutine1  I tested in IE11 and Chrome49   you will see it sleep 3 seconds between two console statements  It keeps the codes as pretty as the traditional style  The tricky is in sleepFor routine  It reads the caller function body as string and break it into 2 parts  Remove the upper part and create another function by lower part  After waiting for the specified number of milliseconds  it calls the created function by applying the original context and arguments  For the original flow  it will end by  return  as usual  For the  yield   It is used for regex matching  It is necessary but no use at all   It is not 100  perfect at all but it achieves my jobs at least  I have to mention some limitations in using this piece of codes  As the code is being broken into 2 parts  the  return  statement must be in outer  instead of in any loop or     i e   function coroutine3         this a   100      console log  coroutine3-1 start        if true            return sleepFor 3000  yield            lt - raise exception here     console log  coroutine3-2 complete        this a        The above codes must have problem as the close bracket could not exist individually in the created function  Another limitation is all local variables declared by  var xxx 123  could not carry to next function  You must use  this xxx 123  to achieve the same thing  If your function has arguments and they got changes  the modified value also could not carry to next function   function coroutine4 x       assume x abc     var z   x      x    def       console log  coroutine4-1 start    z   x     z abc  x def     return sleepFor 3000  yield      console log  coroutine4-2     z   x     z undefined  x abc     I would introduce another function prototype  waitFor  waitFor   function check  ms        var caller   arguments callee caller toString        var funcArgs         s S       gi exec caller  1       var args   arguments callee caller arguments      var funcBody   caller replace     s S   waitFor  s S   yield     s     g          var context   this      var thread   setInterval function             if check                  clearInterval thread               new Function funcArgs  funcBody  apply context  args                    ms ms 100       return this      It waits for  check  function until it returns true  It checks the value every 100ms  You can adjust it by passing additional argument  Consider the testing coroutine2   function coroutine2 c           some codes here        this a   1      console log  coroutine2-1     this a         return sleepFor 500  yield          next        console log  coroutine2-2     this a         console log  coroutine2-2 waitFor c a gt 100     c a       return waitFor function             return c a gt 100         yield          the rest of code        console log  coroutine2-3     this a         Also in pretty style we love so far  Actually I hate the nested callback  It is easily understood that the coroutine2 will wait for the completion of coroutine1  Interesting  Ok  then run the following codes   this a   10  console log  outer-1     this a     var c1   new coroutine1    var c2   new coroutine2 c1   console log  outer-2     this a       The output is   outer-1 10 coroutine1-1 start coroutine2-1 1 outer-2 11 coroutine2-2 2 coroutine2-2 waitFor c a gt 100 100 coroutine1-2 complete coroutine2-3 3   Outer is immediately completed after initialised coroutine1 and coroutine2  Then  coroutine1 will wait for 3000ms  Coroutine2 will enter into step 2 after waited for 500ms  After that  it will continue step 3 once it detects the coroutine1 a values   100   Beware of that there are 3 contexts to hold variable  a   One is outer  which values are 10 and 11  Another one is in coroutine1  which values are 100 and 101  The last one is in coroutine2  which values are 1 2 and 3  In coroutine2  it also waits for c a which comes from coroutine1  until its value is greater than 100  3 contexts are independent   The whole code for copy amp paste   sleepFor   function ms        var caller   arguments callee caller toString        var funcArgs         s S       gi exec caller  1       var args   arguments callee caller arguments      var funcBody   caller replace     s S   sleepFor  s S   yield     s     g          var context   this      setTimeout function             new Function funcArgs  funcBody  apply context  args          ms       return this     waitFor   function check  ms        var caller   arguments callee caller toString        var funcArgs         s S       gi exec caller  1       var args   arguments callee caller arguments      var funcBody   caller replace     s S   waitFor  s S   yield     s     g          var context   this      var thread   setInterval function             if check                  clearInterval thread               new Function funcArgs  funcBody  apply context  args                    ms ms 100       return this     function coroutine1         this a   100      console log  coroutine1-1 start        return sleepFor 3000  yield      console log  coroutine1-2 complete        this a       function coroutine2 c           some codes here        this a   1      console log  coroutine2-1     this a         return sleepFor 500  yield          next        console log  coroutine2-2     this a         console log  coroutine2-2 waitFor c a gt 100     c a       return waitFor function             return c a gt 100         yield          the rest of code        console log  coroutine2-3     this a        this a   10  console log  outer-1     this a     var c1   new coroutine1    var c2   new coroutine2 c1   console log  outer-2     this a       It is tested in IE11 and Chrome49  Because it uses arguments callee  so it may be trouble if it runs in strict mode

User · Answer

ONE-LINER using Promises const sleep   t   gt  new Promise s   gt  setTimeout s  t     DEMO  x000D   x000D  const sleep   t   gt  new Promise s   gt  setTimeout s  t       usage async function demo            count down     let i   6      while  i--            await sleep 1000           console log i                sum of numbers 0 to 5 using by delay of 1 second     const sum   await     Array 6  keys    reduce async  a  b    gt            a   await a          await sleep 1000           const result   a   b          console log    a      b      result             return result         Promise resolve 0        console log  sum   sum     demo    x000D   x000D   x000D

User · Answer

One scenario where you might want a sleep   function rather than using setTimeout   is if you have a function responding to a user click that will ultimately end up opening a new i e  popup window and you have initiated some processing that requires a short period to complete before the popup is displayed  Moving the open window into a closure means that it typically gets blocked by the browser

User · Answer

The problem with using an actual sleep function is that JavaScript is single-threaded and a sleep function will pretty much make your browser tab hang for that duration

User · Answer

A very simple way to do do sleep  that WILL be compatible with anything that runs Javascript    This code has been tested with something like 500 entries  CPU and memory usage still not visible on my web browsers   Here one function that wait until the node becomes visible      This function creates a new context function       to avoid recursion   We placed a code that does the same as the caller code inside this new context   We use the function Timeout to call our function after a few time second      var get hyper   function  node   maxcount   only relation        if  node offsetParent     null                   node is hidden             setTimeout function      get hyper node   maxcount   only relation                          1000               return                 Enter here the code that wait that that the node is visible        before getting executed

User · Answer

Could do something like this  A sleep method that all functions can inherit   x000D   x000D  Function prototype sleep   function delay     args    x000D      setTimeout      gt  this    args   delay  x000D    x000D   x000D  console log sleep 2000   Hello world    x000D   x000D   x000D

User · Answer

In sleep method you can return any then-able object  and not necessarily a new promise  example    x000D   x000D  const sleep    t    gt      then   r    gt  setTimeout r  t      const someMethod   async      gt         console log  hi        await sleep 5000      console log  bye       someMethod   x000D   x000D   x000D

User · Answer

It might me a little late and a little lazy and a little boring or a little intrusive or a little like  back of  bigmouth   but     Each and any solution I ve read so far would be like  let s get to sleep and look what happened  tomorrow    setInterval callback  time  would wait time long and then call the callback  WHILE blocking the runtime  The current implementation of  setInterval  is far from being thread-save  not even to mind concurrency   While the sparse solutions mentioned look like  guess what  C   laughs   they still don t work like in C   NET  They still work like in C   JavaScript currently does NOT provide an architecture to accomplish real multi-threading  The best approach would be TypeScript  but still this lacks so much of a real solution that it    hurts  JavaScript  and jQuery  and AJAX  and jNode  and even TypeScript are just a bunch of Wannabes relying on the goods and bads of the moods of the implementors  Fact  Full stop

User · Answer

See the updated answer for 2016   I think it s perfectly reasonable to want to perform an action  wait  then perform another action  If you are used to writing in multi-threaded languages  you probably have the idea of yielding execution for a set amount of time until your thread wakes up   The issue here is that JavaScript is a single-thread event-based model  While in a specific case  it might be nice to have the whole engine wait for a few seconds  in general it is bad practice  Suppose I wanted to make use of your functions while writing my own  When I called your method  my methods would all freeze up  If JavaScript could somehow preserve your function s execution context  store it somewhere  then bring it back and continue later  then sleep could happen  but that would basically be threading   So you are pretty much stuck with what others have suggested -- you ll need to break your code up into multiple functions   Your question is a bit of a false choice  then  There is no way to sleep in the way you want  nor should you pursue the solution you suggest

User · Answer

A method of an object that needs to use a  sleep  method such as the following   function SomeObject         this SomeProperty    xxx       return this    SomeObject prototype SomeMethod   function          this DoSomething1 arg1       sleep 500       this DoSomething2 arg1       Can almost be translated to   function SomeObject         this SomeProperty    xxx       return this    SomeObject prototype SomeMethod   function  arg1        var self   this      self DoSomething1 arg1       setTimeout function              self DoSomething2 arg1          500       The difference is that the operation of  SomeMethod  returns before the operation  DoSomething2  is executed  The caller of  SomeMethod  cannot depend on this  Since the  Sleep  method does not exists  I use the later method and design my code accordingly   I hope this helps

User · Answer

Use three functions    A function which calls setInterval to start the loop A function which calls clearInterval to stop the loop  then calls setTimeout to sleep  and finally calls to within the setTimeout as the callback to restart the loop A loop which tracks the number of iterations  sets a sleep number and a maximum number  calls the sleep function once the sleep number has been reached  and calls clearInterval after the maximum number has been reached    x000D   x000D  var foo       x000D   x000D  function main   x000D      x000D     use strict   x000D      Initialize global state   x000D    foo bar   foo bar    0  x000D       Initialize timer     x000D    foo bop   setInterval foo baz  1000    x000D      x000D    x000D   sleep    x000D        function timer  x000D          x000D         use strict   x000D        clearInterval timer   x000D        timer   setTimeout function   main     5000   x000D           x000D          x000D    x000D   foo baz    x000D     function   x000D          x000D         use strict   x000D           Update state    x000D        foo bar   Number foo bar   1     0   x000D           Log state    x000D        console log foo bar   x000D           Check state and stop at 10     x000D         foo bar     5   amp  amp  sleep foo bop   x000D         foo bar     10   amp  amp  clearInterval foo bop   x000D           x000D         x000D  main    x000D   x000D   x000D      References   Game Development Using JavaScript Why the Scroll Event Change in iOS 8 is a Big Deal A live polling system in Ember js Driving Animation with requestAnimationFrame   MDN  JavaScript Concurrency Model and the Event Loop Grid Studies  Node js Beating 60fps in JavaScript Part 2  CPU intensive javascript computations without blocking the single thread

User · Answer

The short answer is NO  not in javascript by itself   You solution seems to be the only way to not return control back to the environment   This is necessary if the environment does not support events   They probably wouldn t support the settimeout either   settimeout is definitely the best way if you are in an event driven environment suchas a browser or node js

User · Answer

Using Typescript   Here s a quick sleep   implementation that can be awaited   This is as similar as possible to the top answer   It s functionally equivalent except ms is typed as number for typescript   const sleep    ms  number    gt    new Promise  resolve    gt  setTimeout resolve  ms     async function demo       console log  Taking a break for 2s  2000ms          await sleep 2000     console log  Two seconds later       demo      This is it  await sleep  lt duration gt     Note that    await can only be executed in functions prefixed with the async keyword  or at the top level of your script in some environments  e g  the Chrome DevTools console  or Runkit   await only pauses the current async function

User · Answer

For the specific case of wanting to space out a set of calls being executed by a loop  you can use something like the code below with prototype  Without prototype  you can substitute the delay function with setTimeout   function itemHandler item        alert item      var itemSet     a   b   c        Each call to itemHandler will execute    1 second apart for var i 0  i lt itemSet length  i          var secondsUntilExecution   i      itemHandler delay secondsUntilExecution  item

User · Answer

function sleep milliseconds      var start   new Date   getTime      for  var i   0  i  lt  1e7  i          if   new Date   getTime   - start   gt  milliseconds         break

User · Answer

Here you go   As the code says  don t be a bad dev and use this on websites   It s a development utility function      Basic sleep function based on ms     DO NOT USE ON PUBLIC FACING WEBSITES  function sleep ms        var unixtime ms   new Date   getTime        while new Date   getTime    lt  unixtime ms   ms

User · Answer

I agree with the other posters  a busy sleep is just a bad idea   However  setTimeout does not hold up execution  it executes the next line of the function immediately after the timeout is SET  not after the timeout expires  so that does not accomplish the same task that a sleep would accomplish   The way to do it is to breakdown your function in to before and after parts    function doStuff         do some things   setTimeout continueExecution  10000    wait ten seconds before continuing    function continueExecution          finish doing things after the pause     Make sure your function names still accurately describe what each piece is doing  I E  GatherInputThenWait and CheckInput  rather than funcPart1 and funcPart2   Edit   This method achieves the purpose of not executing the lines of code you decide until AFTER your timeout  while still returning control back to the client PC to execute whatever else it has queued up   Further Edit  As pointed out in the comments this will absolutely NOT WORK in a loop  You could do some fancy  ugly  hacking to make it work in a loop  but in general that will just make for disastrous spaghetti code

User · Answer

Most of the answers here are misguided or at the very least outdated  There is no reason javascript has to be single threaded  and indeed it isnt t  Today all the mainstream browsers support workers  before this was the case other javascript runtimes like Rhino and Node js supported multithreading    Javascript is single threaded  is not a valid answer  For example running a sleep function within a worker would not block any of the code running in the ui thread   In newer runtimes supporting generators and yield  one could bring similar functionality to the sleep function in a single threaded environment      This is based on the latest ES6 drafts     js 1 7   SpiderMonkey Firefox 2   syntax is slightly different     run code you want to sleep here  ommit star if using js 1 7  function  main        for  var i   0  i  lt  10  i                 to sleep for 10 milliseconds 10 times in a row         yield 10             yield 5      console log  I just slept 5 milliseconds           resume the given generator after ms milliseconds function resume ms  generator       setTimeout function               ommit  value if using js 1 7         var nextSleep   generator next   value          resume nextSleep  generator          ms         initialize generator and get first sleep for recursive function var     generator   main        firstSleep   generator next   value      initialize recursive resume function resume firstSleep  generator     This imitation of sleep is different from a true sleep function as it does not block the thread  It is simply sugar on top of javascript s current setTimeout function  This functionality type has been implemented in Task js and should work today in Firefox

User · Answer

There s a new library that neatly chains functions together with timeouts so you can avoid callback hell   Sequencr js  Turns this   setTimeout function timeout       function1        setTimeout function timeout           function2            setTimeout function timeout               function3               timeout  timeout         timeout  timeout     10  10     into this   Sequencr chain  function1  function2  function3   10     And has built-in support for loops that  sleep  between each iteration

User · Answer

If you want code that is usable on all browsers  then use setTimeout   and clearTimeout     If you re reading this far into answers  you ll probably notice that the accepted answer breaks all JavaScript compilation in Internet Explorer 11  and after using this solution  it seems that 5  of users approximately still use this actively-developed browser and require support  This has broken almost everything   There are known reports of arrow functions breaking IE11 functionality for the software of Drupal  WordPress  Amazon AWS  IBM  and there s even a dedicated discussion to it on StackOverflow  Just check it out      Use setTimeout   and clearTimeout    and that will do the trick for all browsers    Working JSBin Demo  x000D   x000D  var timeout   function sleep delay            if timeout                clearTimeout timeout                     timeout   setTimeout function                 myFunction               delay        console log  sleep for 1 second    sleep 1000    function myFunction       console log  slept for 1 second       x000D   x000D   x000D

User · Answer

2017     2021 update Since 2009 when this question was asked  JavaScript has evolved significantly  All other answers are now obsolete or overly complicated  Here is the current best practice   x000D   x000D  function sleep ms      return new Promise resolve   gt  setTimeout resolve  ms       async function demo       console log  Taking a break         await sleep 2000     console log  Two seconds later  showing sleep in a loop             Sleep in loop   for  let i   0  i  lt  5  i          if  i     3        await sleep 2000       console log i          demo    x000D   x000D   x000D   This is it  await sleep  lt duration gt    Or as a one-liner  await new Promise r   gt  setTimeout r  2000     Note that   await can only be executed in functions prefixed with the async keyword  or at the top level of your script in an increasing number of environments  await only pauses the current async function  This means it s not blocking the execution of the rest of the script  which is what you want in the vast majority of the cases  If you do want a blocking construct  see this answer using Atomics wait  but note that most browsers will not allow it on the browser s main thread   Two new JavaScript features  as of 2017  helped write this  quot sleep quot  function   Promises  a native feature of ES2015  aka ES6   We also use arrow functions in the definition of the sleep function  The async await feature lets the code explicitly wait for a promise to settle  resolve or reject    Compatibility  promises are supported in Node v0 12  and widely supported in browsers  except IE async await landed in V8 and has been enabled by default since Chrome 55  released in Dec 2016   it landed in Node 7 in October 2016 and also landed in Firefox Nightly in November 2016    If for some weird reason you re using Node older than 7  which has reached end of life   or are targeting old browsers  async await can still be used via Babel  a tool that will transpile JavaScript   new features into plain old JavaScript   with the transform-async-to-generator plugin

User · Answer

At server side  you can use the deasync sleep   method  which is natively implemented in C so it can effectively implement a wait effect without blocking the event-loop or putting your CPU at 100  of load   Example      usr bin env node     Requires  npm install --save deasync  var sleep   require  deasync   sleep   sleep 5000    console log   Hello World        But  if you need a pure javascript function  for example  to run it at client-side by a browser   I m sorry to say that I think your pausecomp   function is the only way to approach it and  more than that    That pauses not only your function but the whole event loop  So no other events will be attended  It puts your cpu at 100  load    So  if you need it for a browser script and doesn t want those terrible effects  I must say you should rethink your function in a way   a   You can recall it  or call a do the rest   function  at a timeout  The easier way if you are not expecting any result from your function   b   Or  if you need to wait for a result  then you should move to using promises  or a callback hell  of course  -     No result expected example   function myFunc          console log   Do some things         setTimeout function doTheRest            console log   Do more things              5000           Returns undefined       myFunc      Example returning a promise  notice it alters your function usage    function myFunc someString         return new Promise function resolve  reject             var result    someString           result push  Do some things             setTimeout function                result push  Do more things                   resolve result join   n                5000                     But notice that this approach affect to the function usage        It returns a promise  not actual data   myFunc  Hello     then function data       console log data      catch function err       console error err

User · Answer

Embrace the asyncronous nature of javascript   All of the following will return immediately but have a single place for putting code you want to run after something has happened     The methods I ve outlined here are all for different use cases and are roughly ordered in terms of their complexity   The different things are as follows    Waiting for some condition to become true Waiting for a set of methods to finish  in any order  before calling a single callback Running a series of asyncronous methods with shared state in a particular order before calling a callback   Wait  Waiting to see if some condition is true is usedful where there is no accessible callback to tell you when something has finished executing   This is a pretty basic implementation that assumes that the condition will become true at some point   With a few tweaks it could be expanded to be even more useful  eg by setting a call limit     I only wrote this one yesterday    function waitFor predicate  successCallback        setTimeout function              var result   predicate            if  result     undefined              successCallback result           else             waitFor predicate  successCallback          100       calling code       beforeEach function  done            selectListField  A field             waitFor function                  var availableOptions   stores scrapeStore optionStore               if  availableOptions length     0                  return availableOptions             done             Here I m calling something which loads an extjs  store  and waiting til the store contains something before continuing  the beforeEach is a jasmine test framework thing    Wait for several things to complete  Another thing I needed to do was run a single callback after a load of different methods finished   You can do that like this   createWaitRunner   function  completionCallback        var callback   completionCallback      var completionRecord           var elements   0       function maybeFinish             var done   completionRecord every function  element                return element     true                      if  done              callback               return           getNotifier  function  func                func   func    function                    var index   elements                completionRecord index    false               return function                      func applyTo arguments                   completionRecord index    true                  maybeFinish                                       calling code       var waiter   createWaitRunner done        filterList bindStore   waiter getNotifier        includeGrid reconfigure   waiter getNotifier function  store            includeStore   store              excludeGrid reconfigure   waiter getNotifier function  store            excludeStore   store            You either just wait for the notifications or can also wrap other functions which use the values passed to the function   When all the methods are called then done will be run   Running asynchronous methods in order  I ve used a different approach when I had a series of asynchronous methods to call in a row  again in tests    This is somewhat similar to something you can get in the Async library - series does about the same thing and I had a little read of that library first to see if it did what I wanted   I think mine has a nicer api for working with tests though    it was fun to implement       provides a context for running asyncronous methods syncronously   the context just provides a way of sharing bits of state   use run to execute the methods   These should be methods that take a callback and optionally the context as arguments   note the callback is provided first so you have the option of just partially applying your function to the arguments you want   instead of having to wrap even simple functions in another function    when adding steps you can supply either just a function or a variable name and a function   if you supply a variable name then the output of the function  which should be passed into the callback  will be written to the context createSynchronisedRunner   function  doneFunction        var context            var currentPosition   0      var steps              this is the loop  it is triggered again when each method finishes     var runNext   function              var step   steps currentPosition           step func call null                         function  output                               step outputHandler output                              currentPosition                                if  currentPosition     steps length                                 return                              runNext                              context               var api            api addStep   function  firstArg  secondArg            var assignOutput          var func             overloads         if  secondArg     undefined                assignOutput   function                                 func   firstArg                    else               var propertyName   firstArg              assignOutput   function  output                    context propertyName    output                             func   secondArg                     steps push                          func  func                         outputHandler  assignOutput                                    api run   function  completedAllCallback            completedAllCallback   completedAllCallback    function               var lastStep   steps steps length - 1           var currentHandler   lastStep outputHandler          lastStep outputHandler   function  output                currentHandler output               completedAllCallback context               doneFunction                        runNext                  this is to support more flexible use where you use a done function in a different scope to initialisation       eg the done of a test but create in a beforeEach     api setDoneCallback   function  done            doneFunction   done              return api       calling code   beforeAll function  done        var runner   createSynchronisedRunner done       runner addStep  attachmentInformation   testEventService getAttachmentCalled partiallyApplyTo  cat eating lots of memory jpg         runner addStep  attachment   getAttachment partiallyApplyTo  cat eating lots of memory jpg         runner addStep  noAttachment   getAttachment partiallyApplyTo  somethingElse jpg         runner run function  context            attachment   context attachment          noAttachment   context noAttachment                PartiallyApplyTo here is basically a renamed version of Doug Crockford s implementation of Curry   A lot of the stuff I m working with takes a callback as the final argument so simple calls can be done like this rather than having to wrap everything with an extra func   Hopefully some of the ideas in there might be useful to people

User · Answer

I think the question is great and points out important perspectives and considerations  With that said  I think the core of the question is in the intention and understanding what developer  you  wants to have controlled  First  the name sleep is an overloaded naming choice  I e    quot what quot  is going to be  quot slept quot   and  quot what quot  as a developer am I in control of   In any language-engine  running on any OS process  on any bare-metal-or-hosted system the  quot developer quot  is NOT in control  owner  of the OS-shared-resource CPU core s   and or threads  unless they are the writing the OS Process system itself  CPUs are a time-shared resource  and the currency of work-execution progress are the  quot cycles quot  allocated amongst all work to be performed on the system   As an app service developer  it is best to consider that I am in control of a workflow-activity-stream managed by a os-process language-engine  On some systems that means I control a native-os-thread  which likely shares CPU cores   on others it means I control an async-continuation-workflow chain tree  In the case of JavaScript  it is the  quot latter quot   So when  quot sleep quot  is desired  I am intending to cause my workflow to be  quot delayed quot  from execution for some period of time  before it proceeds to execute the next  quot step quot   phase activity task  in its workflow  This is  quot appropriately quot  saying that as a developer it is easiest to  think in terms of  model work as a linear-code flow  resorting to compositions of workflows to scale as needed   Today  in JavaScript  we have the option to design such linear work flows using efficient multi-tasking 1980s actor based continuation architectures  relabeled as modern Futures Promises then await etc    With that in mind  my answer is not contributing a new technical solution  but rather focusing on the intent and the design perspective within the question itself  I suggest that any answer begins with thinking about the above concepts and then choosing a NAME  other than sleep  that reminds and suggests what the intention is   Workflow  Choice 1  delayWorkForMs nMsToDelay  Choice 2  delayAsyncSequenceForMs msPeriod    async delayAsyncSequenceForMs msPeriod      await new Promise resolve   gt  setTimeout resolve  msPeriod        Keep in mind that any async function always returns a Promise  and await may only be used within an async function   lol  you might ask yourself why       Consideration 1  do-not use  quot loops quot  to BURN UP cpu-cycles  Consideration 2  In the JavaScript model  when inside a non-async function you cannot  quot delay quot   wait for  an  quot async quot  workflow s execution  unless you are doing bad things needlessly burning cpu cycles   You can only  quot delay quot  code-steps within an  quot async quot  function  Internally  an  quot async quot  function is modelled as a collection of entry-point continuations at each await keyword  If you are familiar with the backtick interpolation model  you can  quot think of await quot  as being conceptually modelled similarly to writing a backquote string like         Conceptualizing  using an interpolation example to illustrate      how to think about  quot await quot  and  quot async quot  functions    code  await then-restart-point more-code  await then-restart-point

User · Answer

This might work  It worked for me in c and javascript   function sleep time     var x   0   for x   0 x  lt  time x        Do nothing

User · Answer

If you really want to block the main thread altogether and keep the event loop from pulling from the event queue  here s a nice way to do that without creating any functions  new Date objects or leaking any variables  I know there s a million answers to this silly question already but I didn t see anyone using this exact solution  This is modern browser only   WARNING  This is not something you would ever put into production  it is just helpful for understanding the browser event loop  It is probably not even useful for any testing  It is not like a normal system sleep function because the javascript runtime is still doing work every cycle    for  let e   performance now     2000  performance now    lt  e         Used here  the setTimeout callback won t be called until at least 2 seconds later even though it enters the event queue almost instantly   setTimeout function       console log  timeout finished       0    for  let e   performance now     2000  performance now    lt  e       console log  haha wait for me first      You will experience a  2 second pause then see  haha wait for me first timeout finished   The benefit of using performance now   over Date now   is that that the Date object is     subject to both clock skew and adjustment of the system clock  The   value of time may not always be monotonically increasing and   subsequent values may either decrease or remain the same        In general performance now   is more suited to measuring differences in time at high accuracy   Using a for loop has the benefit of letting you set variables local to the block before running  This allows you to do the addition math outside the loop while still being a  one-liner   This should hopefully minimize the CPU load of this hot cycle burn

User · Answer

I can understand the purpose of a sleep function if you have to deal with synchronous execution  The setInterval and setTimeout functions create a parallel execution thread which returns the execution sequence back to the main program  which is ineffective if you have to wait for a given result  Of course one may use events and handlers  but in some cases is not what is intended

User · Answer

In case you really need a sleep   just to test something  But be aware that it ll crash the browser most of the times while debuggin - probably that s why you need it anyway  In production mode I ll comment out this function   function pauseBrowser millis        var date   Date now        var curDate   null      do           curDate   Date now          while  curDate-date  lt  millis       Don t use new Date   in the loop  unless you want to waste memory  processing power  battery and possibly the lifetime of your device

User · Answer

If you right a sleep function like this  var sleep   function period  decision  callback       var interval   setInterval function            if  decision                  interval   clearInterval interval               callback                     period       and you have a asynchronous function to call multiple times  var xhr   function url  callback          make ajax request        call callback when request fulfills     And you setup your project like this   var ready   false   function xhr1        xhr url1  function    ready   true         function xhr2        xhr url2  function    ready   true         function xhr3        xhr url3  function    ready   true           Then you can do this   xhr1    sleep 100  function    return done     xhr2   sleep 100  function    return done     xhr3   sleep 100  function    return done     function           do more       Instead of endless callback indentation like this   xhr url1  function        xhr2 url2  function            xhr3 url3  function                   do more

User · Answer

Here is a way to sleep in a  hta script  such that when the script wakes up it executes the next command in sequence  as is necessary in a loop   This is a real sleep  it does not keep a processor busy during the sleep   E g  the processor is able to download and render pages during the sleep   Just once  near the beginning of the code  go  var WSHShell   new ActiveXObject   WScript Shell      For a sleep of e g  1 second   1000 milliseconds  execute the statement  WSHShell Run   Sleep js 1000   3  true     In the same directory as the script is the file Sleep js  which contains the following one line   WScript Sleep  WScript Arguments  0       Beware  0 is in parentheses  not brackets   The latter is the line that actually performs the sleep   The argument true in the preceding snippet makes the call synchronous   The 3 in the preceding argument seems not to have any effect  but you need some argument so that true is the 3rd argument   Microsoft says  The WScript object     never needs to be instantiated before invoking its properties and methods  and it is always available from any script file    but that s not true   It is available in a free-standing  js file such as the above  but apparently not in a  js file used by a  hta file  so that is why it must be in a separate file  invoked as above

User · Answer

You can t do a sleep like that in JavaScript  or  rather  you shouldn t  Running a sleep or a while loop will cause the user s browser to hang until the loop is done   Use a timer  as specified in the link you referenced

User · Answer

I ve searched for sleep solution too  not for production code  only for dev tests  and found this article   http   narayanraman blogspot com 2005 12 javascript-sleep-or-wait html     and here s another link with client-side solutions  http   www devcheater com   Also  when you are calling alert    your code will be paused too  while alert is shown -- need to find a way to not display alert but get the same effect

User · Answer

I got Promise is not a constructor using the top answer  If you import bluebird you can do this  Simplest solution imo   import   as Promise from  bluebird       await Promise delay 5000

User · Answer

I had a similar problem  having to wait for control existence and checking in intervals  Since there is no real sleep  wait or pause in JavaScript and using await   async is not supported properly in Internet Explorer  I made a solution using setTimeOut and injecting the function in case of successfully finding the element  Here is the complete sample code  so everyone can reproduce and use it for their own project    lt html gt   lt head gt       lt script src  https   ajax googleapis com ajax libs jquery 3 3 1 jquery min js  gt  lt  script gt       lt script type  text javascript  gt          var ElementSearchStatus                 None  0              Found  1              NotFound  2              Timeout  3                     var maxTimeout   5          var timeoutMiliseconds   1000           function waitForElement elementId  count  timeout  onSuccessFunction                  count              var elementSearchStatus   existsElement elementId  count  timeout               if  elementSearchStatus    ElementSearchStatus None                    window setTimeout waitForElement  timeoutMiliseconds  elementId  count  timeout  onSuccessFunction                             else                   if  elementSearchStatus    ElementSearchStatus Found                        onSuccessFunction                                                       function existsElement elementId  count  timeout                var foundElements           elementId               if  foundElements length  gt  0    count  gt  timeout                    if  foundElements length  gt  0                        console log elementId     found                        return ElementSearchStatus Found                                    else                       console log  Search for     elementId     timed out after     count     tries                         return ElementSearchStatus Timeout                                              else                   console log  waiting for     elementId     after     count     of     timeout                   return ElementSearchStatus None                                   function main                 waitForElement  StartButton   0  maxTimeout  function                      console log  found StartButton                     DoOtherStuff  StartButton2                                      function DoOtherStuff elementId                waitForElement elementId  0  maxTimeout  function                      console log  found     elementId                   DoOtherStuff  StartButton3                                   lt  script gt   lt  head gt   lt body gt       lt button type  button  id  StartButton  onclick  main     gt Start Test lt  button gt       lt button type  button  id  StartButton2  onclick  alert  Hey ya Start Button 2     gt Show alert lt  button gt   lt  body gt   lt  html gt

User · Answer

Javascript Functions allow no suspension  With synchronous Javascript procedures are implemented  Procedures await i o operations and sleep timeouts  Available for javascript 1 7   demos   demo sleep demo suspendable procedures

User · Answer

A lot of the answers don t  directly  answer the question  and neither does this one     Here s my two cents  or functions    If you want less clunky functions than setTimeout and setInterval  you can wrap them in functions that just reverse the order of the arguments and give them nice names   function after ms  fn   setTimeout fn  ms     function every ms  fn   setInterval fn  ms       CoffeeScript versions   after    ms  fn - gt  setTimeout fn  ms every    ms  fn - gt  setInterval fn  ms   You can then use them nicely with anonymous functions   after 1000  function        console log  it s been a second        after 1000  function            console log  it s been another second                  Now it reads easily as  after N milliseconds        or  every N milliseconds

User · Answer

I have searched googled quite a few webpages on javascript sleep wait    and there is NO answer if you want javascript to  RUN  DELAY  RUN     what most people got was either   RUN  RUN useless stuff   RUN  or  RUN  RUN   delayed RUN       So I ate some burgers and got thinking    here is a solution that works    but you have to chop up your running codes       yes  I know  this is just an easier to read refactoring    still                                                   example1    lt html gt   lt body gt   lt div id  id1  gt DISPLAY lt  div gt    lt script gt    javascript sleep by  therealdealsince1982   copyrighted 2009   setInterval var i   0   function run           pieces of codes to run     if  i  0  document getElementById  id1   innerHTML    lt p gt code segment    i    is ran lt  p gt          if  i  1  document getElementById  id1   innerHTML    lt p gt code segment    i    is ran lt  p gt          if  i  2  document getElementById  id1   innerHTML    lt p gt code segment    i    is ran lt  p gt          if  i  gt 2  document getElementById  id1   innerHTML    lt p gt code segment    i    is ran lt  p gt          if  i  5  document getElementById  id1   innerHTML    lt p gt all code segment finished running lt  p gt    clearInterval t       end interval  stops run     i      segment of code finished running  next       run    t setInterval  run    1000     lt  script gt   lt  body gt   lt  html gt                                             example2    lt html gt   lt body gt   lt div id  id1  gt DISPLAY lt  div gt    lt script gt    javascript sleep by  therealdealsince1982   copyrighted 2009   setTimeout var i   0   function run           pieces of codes to run  can use switch statement     if  i  0  document getElementById  id1   innerHTML    lt p gt code segment    i    ran lt  p gt    sleep 1000        if  i  1  document getElementById  id1   innerHTML    lt p gt code segment    i    ran lt  p gt    sleep 2000        if  i  2  document getElementById  id1   innerHTML    lt p gt code segment    i    ran lt  p gt    sleep 3000        if  i  3  document getElementById  id1   innerHTML    lt p gt code segment    i    ran lt  p gt       stops automatically     i       function sleep dur   t setTimeout  run    dur      starts flow control again after dur  run      starts  lt  script gt   lt  body gt   lt  html gt                        example3    lt html gt   lt body gt   lt div id  id1  gt DISPLAY lt  div gt    lt script gt    javascript sleep by  therealdealsince1982   copyrighted 2009   setTimeout var i   0   function flow         run i       i      code segment finished running  increment i  can put elsewhere     sleep 1000       if  i  5   clearTimeout t      stops flow  must be after sleep      function run segment          pieces of codes to run  can use switch statement     if  segment  0  document getElementById  id1   innerHTML    lt p gt code segment    segment    is ran lt  p gt          if  segment  1  document getElementById  id1   innerHTML    lt p gt code segment    segment    is ran lt  p gt          if  segment  2  document getElementById  id1   innerHTML    lt p gt code segment    segment    is ran lt  p gt          if  segment  gt 2  document getElementById  id1   innerHTML    lt p gt code segment    segment    is ran lt  p gt         function sleep dur   t setTimeout  flow    dur      starts flow control again after dur  flow      starts flow  lt  script gt   lt  body gt   lt  html gt                     example4    lt html gt   lt body gt   lt div id  id1  gt DISPLAY lt  div gt    lt script gt    javascript sleep by  therealdealsince1982   copyrighted 2009   setTimeout  switch var i   0   function flow         switch i                case 0              run i               sleep 1000               break          case 1              run i               sleep 2000               break          case 5              run i               clearTimeout t     stops flow             break          default              run i               sleep 3000               break           function run segment          pieces of codes to run  can use switch statement     if  segment  0  document getElementById  id1   innerHTML    lt p gt code segment    segment    is ran lt  p gt          if  segment  1  document getElementById  id1   innerHTML    lt p gt code segment    segment    is ran lt  p gt          if  segment  2  document getElementById  id1   innerHTML    lt p gt code segment    segment    is ran lt  p gt          if  segment  gt 2  document getElementById  id1   innerHTML    lt p gt code segment    segment    is ran lt  p gt          i      current segment of code finished running  next       function sleep dur   t setTimeout  flow    dur      starts flow control again after dur  flow      starts flow control for first time     lt  script gt   lt  body gt   lt  html gt

User · Answer

First of all - setTimeout and setInterval is what should be used  because of javascript s callback-ish nature  If you want to use sleep   it s the control flow or the architecture of your code that is incorrect   Having said that I suppose I still can help with two implementation of a sleep    faking synchronous run off the top of my head     a module to do taht   dual-license  MIT or WTF  you can use it anyhow and leave my nickname in a comment if you want to  var    function     var queue      var play function       var go queue shift         if go  if go a  go f   play    else setTimeout play go t           return      go function f       queue push  a 1 f f              sleep function t       queue push  a 0 t t              playback play              making playback automatic should also be possible     usage    go function       your code console log  first             sleep 5000      go function       your code console log  next            this triggers the simulation   playback     real synchronous run   I gave it a lot of thought one day and the only idea I had for a true sleep in javascript is technical   a sleep function would have to be a synchronous AJAX call with a timeout set to the sleep value  That s all and an only way to have a real sleep

User · Answer

The shortest solution without any dependencies   await new Promise resolve   gt  setTimeout resolve  5000

User · Answer

It can be done using Java s sleep method  I ve tested it in FF and IE and it doesn t lock the computer  chew up resources  or cause endless server hits  Seems like a clean solution to me   First you have to get Java loaded up on the page and make its methods available  To do that  I did this    lt html gt   lt head gt    lt script type  text javascript  gt     function load         var appletRef   document getElementById  app        window java   appletRef Packages java         endfunction   lt  script gt    lt body onLoad  load    gt    lt embed id  app  code  java applet Applet  type  application x-java-applet  MAYSCRIPT  true  width  0  height  0    gt    Then  all you have to do when you want a painless pause in your JS is   java lang Thread sleep xxx    Where xxx is time in milliseconds  In my case  by way of justification   this was part of back-end order fulfillment at a very small company and I needed to print an invoice that had to be loaded from the server  I did it by loading the invoice  as a webpage  into an iFrame and then printing the iFrame  Of course  I had to wait until the page was fully loaded before I could print  so the JS had to pause  I accomplished this by having the invoice page  in the iFrame  change a hidden form field on the parent page with the onLoad event   And the code on the parent page to print the invoice looked like this  irrelevant parts cut for clarity    var isReady   eval  document batchForm ready    isReady value 0   frames  rpc frame   location href url   while  isReady value  0      java lang Thread sleep 250        endwhile  window frames  rpc frame   focus    window frames  rpc frame   print      So the user pushes the button  the script loads the invoice page  then waits  checking every quarter second to see if the invoice page is finished loading  then pops up the print dialog for the user to send it to the printer   QED

User · Answer

Here s a simple solution using a synchronous XMLHttpRequest   function sleep n     var request   new XMLHttpRequest      request open  GET     sleep php n     n  false        false  makes the request synchronous   request send null       contents of sleep php    lt  php sleep   GET  n       Now call it with  sleep 5

User · Answer

This will do you the trick   var reloadAfter   10    seconds var intervalId   setTimeout function           code you want to execute after the time waiting    reloadAfter   1000      60000   60 sec   1 min

User · Answer

It is now also possible to use the native module util to promisify regular sync functions   const   promisify     require  util   const sleep   promisify setTimeout   module exports        gt      await someAsyncFunction     await sleep 2000    console log  2 seconds later

[javascript] What is the JavaScript version of sleep()?

Examples related to javascript

Examples related to sleep