I am using the Javascript command:  setInterval.  I like to stop it when the user leaves the page.

This code seems to work well:  http://jsfiddle.net/PQz5k/

It detects when a user leaves a page.  It executes Javascript code when a user clicks on a link to go to a different HTML page or URL, or if user reloads page.

However, it does not work when I go from one AngularJS template to another.  As an example, if I am at template1.html, I want the Javascript code to do something in Controller1.js when the user leaves template1.html to go to template2.html.  What is the equivalent of this code below in AngularJS?:

    $(window).on(&#39;beforeunload&#39;, function() {
        return &#39;Your own message goes here...&#39;;
    });​



In AngularJS, how to detect when user leaves template/page?

This is a pretty simple question really. If I use `setInterval(something, 1000)`, can I be completely sure that after, say, 31 days it will have triggered &quot;something&quot; exactly `60*60*24*31` times?  Or is there any risk for so called drifting?

Will setInterval drift?

Using `setTimeout()` it is possible to launch a function at a specified time:

    setTimeout(function, 60000);

But what if I would like to launch the function multiple times? Every time a time interval passes, I would like to execute the function (every 60 seconds, let&#39;s say).

Calling a function every 60 seconds

I have a `setInterval` running a piece of code 30 times a second. This works great, however when I select another tab (so that the tab with my code becomes inactive), the `setInterval` is set to an idle state for some reason.

I made this simplified test case ([http://jsfiddle.net/7f6DX/3/][1]):

    var $div = $(&#39;div&#39;);
    var a = 0;
    
    setInterval(function() {
        a++;
        $div.css(&quot;left&quot;, a)
    }, 1000 / 30);

If you run this code and then switch to another tab, wait a few seconds and go back, the animation continues at the point it was when you switched to the other tab.

So the animation isn&#39;t running 30 times a second in case the tab is inactive. This can be confirmed by counting the amount of times the `setInterval` function is called each second - this will not be 30 but just 1 or 2 if the tab is inactive.

I guess that this is done by design so as to improve system performance, but is there any way to disable this behavior?

It’s actually a disadvantage in my scenario.

  [1]: http://jsfiddle.net/7f6DX/3/

How can I make setInterval also work when a tab is inactive in Chrome?

I have written a javascript function that uses setInterval to manipulate a string every tenth of a second for a certain number of iterations.

    function timer() {
        var section = document.getElementById(&#39;txt&#39;).value;
        var len = section.length;
        var rands = new Array();

        for (i=0; i&lt;len; i++) {
            rands.push(Math.floor(Math.random()*len));
        };

        var counter = 0
        var interval = setInterval(function() {
            var letters = section.split(&#39;&#39;);
            for (j=0; j &lt; len; j++) {
                if (counter &lt; rands[j]) {
                    letters[j] = Math.floor(Math.random()*9);
                };
            };
            document.getElementById(&#39;txt&#39;).value = letters.join(&#39;&#39;);
            counter++
            
            if (counter &gt; rands.max()) {
                clearInterval(interval);
            }
        }, 100);
    };

Instead of having the interval set at a specific number, I would like to update it every time it runs, based on a counter.  So instead of:

    var interval = setInterval(function() { ... }, 100);

It would be something like:

    var interval = setInterval(function() { ... }, 10*counter);

Unfortunately, that did not work.  It seemed like &quot;10*counter&quot; equals 0.

So, how can I adjust the interval every time the anonymous function runs?

Changing the interval of SetInterval while it&#39;s running

    bigloop=setInterval(function () {
                  var checked = $(&#39;#status_table tr [id^=&quot;monitor_&quot;]:checked&#39;);
                    if (checked.index()===-1 ||checked.length===0 || ){
                        bigloop=clearInterval(bigloop);
                        $(&#39;#monitor&#39;).button(&#39;enable&#39;);
                    }else{
                            
                            (function loop(i) {                           
                                //monitor element at index i
                                monitoring($(checked[i]).parents(&#39;tr&#39;));
                                //delay of 3 seconds
                                setTimeout(function () {
                                    //when incremented i is less than the number of rows, call loop for next index
                                    if (++i &lt; checked.length) loop(i);
                                }, 3000);
                            }(0)); //start with 0
                    }                            
                }, index*3000); //loop period

I have the code above and sometimes it is working, sometimes it is not. I am wondering **if the clearInterval actually clear the timer??** because there is this `monitor` button that will only be disabled when it is in `monitoring` function. I have another `clearInterval` when an element called `.outputRemove` is clicked. See the code below:

    //remove row entry in the table      
            $(&#39;#status_table&#39;).on(&#39;click&#39;, &#39;.outputRemove&#39;, function () {
                deleted= true;
                bigloop= window.clearInterval(bigloop);
                var thistr=$(this).closest(&#39;tr&#39;);
                thistr.remove();
                $(&#39;#monitor&#39;).button(&#39;enable&#39;);
                                              
                $(&#39;#status_table tbody tr&#39;).find(&#39;td:first&#39;).text(function(index){
                   return ++index;
                
                });
            });

But it was enabled for a while before it is disabled again. **Will `clearInterval` get the program out from the `setInterval` function?**

Can clearInterval() be called inside setInterval()?

As far as I can tell, these two pieces of javascript behave the same way:

&lt;strong&gt;Option A:&lt;/strong&gt;

    function myTimeoutFunction()
    {
        doStuff();
        setTimeout(myTimeoutFunction, 1000);
    }

    myTimeoutFunction();

&lt;strong&gt;Option B:&lt;/strong&gt;


    function myTimeoutFunction()
    {
        doStuff();
    }

    myTimeoutFunction();
    setInterval(myTimeoutFunction, 1000);


Is there any difference between using [setTimeout][1] and [setInterval][2]?


  [1]: https://developer.mozilla.org/en-US/docs/Web/API/setTimeout
  [2]: https://developer.mozilla.org/en-US/docs/Web/API/setInterval

setTimeout or setInterval?

I want to use a simple countdown timer starting at 30 seconds from when the function is run and ending at 0. No milliseconds. How can it be coded?



Code for a simple JavaScript countdown timer?

I want to stop this interval in the `error` handler from running repeatedly. Is that possible, and if so, how? 

    // example code
    $(document).on(&#39;ready&#39;,function(){
        setInterval(updateDiv,3000);
    });
    
    function updateDiv(){
        $.ajax({
            url: &#39;getContent.php&#39;,
            success: function(data){
                $(&#39;.square&#39;).html(data);
            },
            error: function(){
                $.playSound(&#39;oneday.wav&#39;);
                $(&#39;.square&#39;).html(&#39;&lt;span style=&quot;color:red&quot;&gt;Connection problems&lt;/span&gt;&#39;);
                // I want to stop it here
            }
        });
    }

Stop setInterval

I need to create a simple but accurate timer.

This is my code:

    var seconds = 0;
    setInterval(function() {
    timer.innerHTML = seconds++;
    }, 1000);


After exactly 3600 seconds, it prints about 3500 seconds.

- Why is it not accurate?

- How can I create an accurate timer?



How to create an accurate timer in javascript?

How can I run a function every minute?
In JavaScript I can do something like `setInterval`, does something similar exist in Swift?

Wanted output:

Hello World once a minute...

Do something every x minutes in Swift

How do I stop and start `setInterval`?

Suppose I have a `textarea`.  I want to stop `setInterval` on focus and restart `setInterval` on blur (with jQuery).

How to stop &quot;setInterval&quot;

How do I reset a `setInterval` timer back to 0?

    var myTimer = setInterval(function() {
      console.log(&#39;idle&#39;);
    }, 4000);

I tried `clearInterval(myTimer)` but that completely stops the interval. I want it to restart from 0.

How do I reset the setInterval timer?

I&#39;m writing an application that utilizes JavaScript timeouts and intervals to update the page. Is there a way to see how many intervals are setup? I want to make sure that I&#39;m not accidentally going to kill the browser by having hundreds of intervals setup.

Is this even an issue?

Viewing all the timeouts/intervals in javascript?

I am working on a music program that requires multiple JavaScript elements to be in sync with another. I’ve been using `setInterval`, which works really well initially. However, over time the elements gradually become out of sync which is bad in a music program.

I’ve read online that `setTimeout` is more accurate, and you can have `setTimeout` loops somehow. However, I have not found a generic version that illustrates how this is possible.

Basically I have some functions like such:

```js
//drums
setInterval(function {
  //code for the drums playing goes here
}, 8000);

//chords
setInterval(function {
  //code for the chords playing goes here
}, 1000);

//bass
setInterval(function {
  //code for the bass playing goes here
}, 500);
```

It works super well, initially, but over the course of about a minute, the sounds become noticeably out of sync as I’ve read happens with `setInterval`. I’ve read that `setTimeout` can be more consistently accurate.

Could someone just show me a basic example of using `setTimeout` to loop something indefinitely? Alternatively, if there is a way to achieve more synchronous results with `setInterval` or even another function, please let me know.

How to make `setInterval` behave more in sync, or how to use `setTimeout` instead?

It&#39;s there a way to configure the `setInterval` method of javascript to execute the method immediately and then executes with the timer

Execute the setInterval function without delay the first time

Does Python have a function similar to JavaScript&#39;s [`setInterval()`][1]?

I would like to have:
```python
def set_interval(func, interval):
    ...
```
That will call `func` every `interval` time units.

  [1]: https://www.w3schools.com/jsref/met_win_setinterval.asp

Python Equivalent of setInterval()?

I need to exit from a running interval if the conditions are correct:

    var refreshId = setInterval(function() {
            var properID = CheckReload();
            if (properID &gt; 0) {
                &lt;--- exit from the loop---&gt;
            }
        }, 10000);

How to exit from setInterval

I am trying to make a webpage that, when it starts loading, uses an Interval to start a timer.

When the page fully loads, it stops the timer,

but 99% of the time i get time measurements of 0.00 or 0.01 even if it takes longer.

Occasionally, it says something that makes more sense like .28 or 3.10 at some times.

Here is the code if it helps:

	var hundredthstimer = 0;
	var secondplace = 0;

	function addinc(){

		hundredthstimer += 1;
		if (inctimer == 100){
			hundredthstimer = 0;
			secondplace += 1;
		}

	}

	var clockint = setInterval(addinc, 10);

	function init(){
		var bconv1 = document.getElementById(&quot;bconverter1&quot;);
		var bconv2 = document.getElementById(&quot;bconverter2&quot;);

		$(bconv2).hide();

		clearInterval(clockint);

		if (inctimer.len !== 2){
			inctimer = &quot;0&quot; + inctimer;
		}
		alert(secondplace + &quot;.&quot; + inctimer);
	}
	onload = init;



So it basically creates a variable called hundredthstimer which is increased by &#39;1&#39; every 10 miliseconds(.01 seconds).

Then, if this number reaches 1000(1 full second), a variable called secondsplace goes up by 1, since that is how many full seconds it has run for.

Then, it alerts secondsplace, a decimal point, and hundredthsplace as the total load time.


But the problem above with incorrect numbers still exists. Why?

Calculating Page Load Time In JavaScript

How do I pause and resume the setInterval() function using Javascript?

For example, maybe I have a stopwatch to tell you the number of seconds that you have been looking at the webpage. There is a &#39;Pause&#39; and &#39;Resume&#39; button. The reason why **clearInterval() would not work here** is because if the user clicks on the &#39;Pause&#39; button at the 40th second and 800th millisecond, when he clicks on the &#39;Resume&#39; button, the number of seconds elapsed must increase by 1 after 200 milliseconds. If I use the clearInterval() function on the timer variable (when the pause button is clicked) and then using the setInterval() function on the timer variable again (when the resume button is clicked), the number of seconds elapsed will increase by 1 only after 1000 milliseconds, which destroys the accuracy of the stopwatch.

So how do I do that?

How can I pause setInterval() functions?

In a simple `setInterval`

    setInterval(function() {
          // Do something every 9 seconds
    }, 9000);

The first action will happen after 9 seconds (`t=9s`). How to force the loop to perform the first action immediately (`t=0`)?

I think it is due to the mechanism of `setInterval` to have `Delay - Action - Delay - Action ...` loop; instead of `Action - Delay - Action - Delay ...` loop.

**EDIT:** My function is indeed a loop as

    setInterval(function(){
    $(&#39;.test&#39;).each(function(idx){
        var duration = 1000;
        $(this).delay(duration*idx);
        Some stuff here
    });
    }, 4000);

How to start setInterval loop immediately?

    myInterval = setInterval(function(){
         MyFunction();
    },50);

    function MyFunction()
    {
        //Can I call clearInterval(myInterval); in here?
    }

The interval&#39;s not stopping (not being cleared), if what I&#39;ve coded above is fine then it&#39;ll help me look elsewhere for what&#39;s causing the problem. Thanks.

EDIT: Let&#39;s assume it completes a few intervals before clearInterval is called which removes the need for setTimeout.

Javascript setInterval function to clear itself?

I read somewhere that setInterval is CPU intensive. I created a script that uses setInterval and monitored the CPU usage but didn&#39;t notice a change. I want to know if there is something I missed.

What the code does is check for changes to the hash in the URL (content after #) every 100 milliseconds and if it has changed, load a page using AJAX. If it has not changed, nothing happens. Would there be any CPU issues with that.

Is setInterval CPU intensive?

I am using `setInterval(fname, 10000);` to call a function every 10 seconds in JavaScript. Is it possible to stop calling it on some event? 

I want the user to be able to stop the repeated refresh of data.

Stop setInterval call in JavaScript

I have this counter I made but I want it to run forever, it&#39;s really simple, what am I doing wrong here?


    function timer() {
      console.log(&quot;timer!&quot;)
    }
  
    window.setInterval(timer(), 1000)


Why does the setInterval callback execute only once?

I need to access `this` from my `setInterval` handler

    prefs: null,
    startup : function()
    	{
            // init prefs
            ...
    	    this.retrieve_rate();
    	    this.intervalID = setInterval(this.retrieve_rate, this.INTERVAL);
    	},

    retrieve_rate : function()
        {
            var ajax = null;
            ajax = new XMLHttpRequest();
            ajax.open(&#39;GET&#39;, &#39;http://xyz.com&#39;, true);
            ajax.onload = function()
            {
                // access prefs here
            }
        }

How can I access this.prefs in `ajax.onload` ?


Javascript setInterval and `this` solution

Currently developing a JavaScript based animation project.

I have noticed that, proper use of `setInterval()`, `setTimeout()` and even `requestAnimationFrame` allocates memory without my request, and causes frequent garbage collection calls. More GC calls = flickers :-(

For instance; when I execute the following **simple code** by calling init() in Google Chrome, memory allocation + garbage collection is fine for the first 20-30 seconds...

    function init()
    {
        var ref = window.setInterval(function() { draw(); }, 50);
    }
    
    function draw()
    {
        return true
    }

Somehow, within a minute or so, starts a strange increase in allocated memory! Since init() is called only for once, **what is the reason for the increase in allocated memory size?**

**(Edit: chrome screenshot uploaded)**

![chrome screenshot][1]

NOTE #1: Yes, I have tried calling clearInterval() before the next setInterval(). Problem remains the same!

NOTE #2: In order to isolate the problem, I&#39;m keeping the above code simple and stupid.


  [1]: http://i.stack.imgur.com/TNuct.png

Does JavaScript setInterval() method cause memory leak?

Please advise how to pass parameters into a function called using `setInterval`.

My example `setInterval(funca(10,3), 500);` is incorrect. 

Pass parameters in setInterval function

For a simple web app that needs to refresh parts of data presented to the user in set intervals, are there any downsides to just using `setInterval()` to get a JSON from an endpoint instead of using a proper polling framework?

For the sake of an example, let&#39;s say I&#39;m refreshing the status of a processing job every 5 seconds.

Using setInterval() to do simplistic continuous polling

I need to implement a function to run after 60 seconds of clicking a button. Please help, I used the Timer class, but I think that that is not the best way.

All Setinterval Solutions on Gang of Coders

Total of 30 Setinterval Solutions