window.setInterval() repeatedly calls a function with a fixed delay between each run (MDN). It returns an interval ID — pass that ID to clearInterval() to stop. For a one-shot delay, use setTimeout().
Pass the required arguments shown below. Check return values and browser support before you rely on the result.
Call window.setInterval. Start with this line.
setInterval(fn, delay, ...args)| Call | What it does |
|---|---|
setInterval(fn, delay, ...args) | Primary signature. |
window.setInterval(...) | Call with the arguments your case needs. |
Built into the browser. Call window.setInterval(...) (or the global setInterval(...)) — no import required.
setInterval(fn, delay, ...args)| Parameter | Description |
|---|---|
| func | Required. Function to run each tick |
| delay | Optional. Milliseconds between runs (default 0) |
| param1…N | Optional. Forwarded to func each tick |
| Return Value | Description |
|---|---|
| * | Pass to clearInterval() |
MDN: schedule a callback every fixed delay.
const id = setInterval(function () {
console.log("tick");
}, 1000);
// later: clearInterval(id);setInterval registers the callback.clearInterval(id) when done.MDN: arguments after delay are forwarded to the callback.
function greet(name) {
console.log("Hello, " + name);
}
const id = setInterval(greet, 2000, "Alex");
// later: clearInterval(id);greet expects a name."Alex" is passed each tick.setInterval(() => greet("Alex"), 2000).clearInterval(id).clearIntervalMDN: cancel the repeating timer with the stored ID.
let n = 0;
const id = setInterval(function () {
n += 1;
console.log(n);
if (n >= 3) {
clearInterval(id);
console.log("stopped");
}
}, 500);MDN-style: guard against starting twice; clear on stop.
let id = null;
let count = 0;
function start() {
if (id !== null) return;
id = setInterval(function () {
count += 1;
console.log(count);
}, 1000);
}
function stop() {
clearInterval(id);
id = null;
}start if already running.id for later clear.clearInterval then set id = null.setInterval creates a new ID.setInterval vs setTimeoutOne repeats; the other runs once. MDN recommends recursive setTimeout when work may overrun the delay.
// repeats until cleared
const i = setInterval(() => console.log("interval"), 1000);
// runs once
setTimeout(() => console.log("timeout once"), 1000);
// later:
clearInterval(i);setTimeout after finish.Window.setInterval() is marked Baseline Widely available on MDN (since July 2015). It is not Deprecated, Experimental, or Non-standard. Available in browsers and workers; prefer function callbacks over string code.
Repeat a callback on a fixed delay across modern browsers.
Bottom line: Universal timer API. Always store the ID and clear when finished; avoid string code.
Run a function once after a delay.
11 people found this page helpful