Skip to content
Subscribe to RSS Find me on GitHub Follow me on Twitter

Calling a Function Every Second in JavaScript


Calling a function at regular intervals is a common task in JavaScript. It allows us to perform repetitive actions, update data dynamically, or create animations. JavaScript provides several methods for achieving this, and in this article, we will explore different approaches to calling a function every second.

Periodically calling a function is important because it enables us to execute tasks that require continuous updates or real-time interaction. For example, updating a clock, fetching data from an API, or creating a slideshow are all scenarios where calling a function every second is necessary to provide a smooth user experience. By understanding the various methods available, we can choose the most suitable approach for our specific use case.

Method 1: setInterval() function

The setInterval() function is a built-in JavaScript function that allows you to call a specified function repeatedly at a given interval. It is commonly used when you need to perform a certain task periodically, such as updating the time on a clock or fetching data from a server.

The syntax for setInterval() is as follows:

setInterval(function, delay, arg1, arg2, ...)
  • function is the name of the function that you want to call repeatedly.
  • delay is the time interval in milliseconds between each function call.
  • arg1, arg2, etc. are optional arguments that can be passed to the function.

Here is an example code snippet that demonstrates the usage of setInterval():

function updateCounter() {
  // Code to update the counter

setInterval(updateCounter, 1000);

In this example, the updateCounter() function will be called every 1000 milliseconds (1 second) to update the counter.

Method 2: setTimeout() function and recursion

The setTimeout() function is another way to call a function at regular intervals in JavaScript. Unlike setInterval(), which repeatedly executes the function every specified time interval, setTimeout() only executes the function once after the specified delay.

To achieve a continuous loop with a delay between each execution, we can use recursion in conjunction with setTimeout(). Recursion is a technique where a function calls itself until a specific condition is met.

Here's how the setTimeout() function is used in combination with recursion to call a function every second:

function myFunction() {
  // Code to be executed every second
  console.log("Hello, World!");

  // Call the function again after 1 second
  setTimeout(myFunction, 1000);

// Initial call to start the loop

In the above example, the myFunction() function is called initially to start the loop. Inside the function, we have the code that needs to be executed every second, which in this case is printing "Hello, World!" to the console. After that, we use setTimeout() to call myFunction() again after a delay of 1 second (1000 milliseconds).

By using recursion and setTimeout(), the function will continuously execute itself every second, creating a loop that calls the desired function at regular intervals.

This approach is useful when we need to perform some task periodically and want more control over the interval between each execution. However, it's important to note that the delay specified in setTimeout() is not guaranteed to be exact, as it depends on the browser's event loop and the workload of the JavaScript engine.

Method 3: setInterval() vs setTimeout()

When it comes to calling a function every second in JavaScript, there are two commonly used methods: setInterval() and setTimeout(). Both these methods allow you to execute a function repeatedly, but they have some key differences.

Comparison of the two methods

setInterval(): This method repeatedly calls a function or executes a code snippet with a fixed time delay between each call. It takes two arguments: the function to be executed and the time delay in milliseconds. The function will keep executing until it is stopped.

setTimeout(): This method executes a function or a code snippet once after a specified delay. It also takes two arguments: the function to be executed and the time delay in milliseconds. However, unlike setInterval(), setTimeout() only runs once.

Pros and cons of each approach

setInterval() has the advantage of automatically scheduling the next call to the function, making it ideal for continuously running tasks. It provides a convenient way to execute code at regular intervals without the need for manual intervention. However, it can be challenging to control the precise timing of function calls, especially if the execution time of the function varies.

setTimeout() is useful when you want to execute a function or code snippet after a specific delay. It allows for more control over the timing of function calls, as you can specify the exact delay before each execution. However, if you want the function to be called repeatedly, you need to use recursion or manually set up additional setTimeout() calls.

Considerations for choosing the appropriate method

When deciding between setInterval() and setTimeout() for calling a function every second, consider the following:

  • Use setInterval() if you want the function to be executed continuously at a fixed interval. This is suitable for tasks like updating real-time data or animations.
  • Use setTimeout() if you need more control over the timing of function calls or want to execute the function only once after a specific delay. This is useful for delayed actions or when the function execution time varies.

It's important to choose the appropriate method based on your specific requirements to ensure the desired functionality and performance of your JavaScript code.

Method 4: Using requestAnimationFrame()

The requestAnimationFrame() method is a built-in JavaScript function that is commonly used for smooth animations and rendering. It is a more efficient alternative to setInterval() when it comes to calling a function repeatedly.

Introduction to requestAnimationFrame()

requestAnimationFrame() is a browser API that allows you to schedule a function to be called before the next repaint. It takes a callback function as an argument, which will be executed just before the browser performs its next repaint.

How to implement a timer using requestAnimationFrame()

To call a function every second using requestAnimationFrame(), you can utilize a recursive approach. Here's an example code snippet:

function callFunctionEverySecond() {
  // Your function logic here

  // Call requestAnimationFrame recursively

// Initial call to start the timer

In the above code, the callFunctionEverySecond() function contains the logic you want to execute every second. By calling requestAnimationFrame() inside the function, you ensure that it will be continuously called at the appropriate time.

Benefits and use cases for requestAnimationFrame()

Using requestAnimationFrame() has several benefits over setInterval() for calling a function every second:

  1. Improved performance: requestAnimationFrame() is optimized by the browser to render animations more efficiently. It ensures that the function is called at the optimal time, aligning with the browser's rendering schedule.

  2. Synchronization with browser rendering: By synchronizing with the browser's rendering cycle, requestAnimationFrame() helps prevent unnecessary paint operations and reduces jank or stuttering in animations.

  3. Battery-friendly: Since requestAnimationFrame() only triggers when the browser is ready to repaint, it consumes less CPU and battery power compared to using setInterval() at a fixed interval.

Use cases for requestAnimationFrame() include:

  • Animations and transitions: requestAnimationFrame() is commonly used for smooth animations and transitions, as it ensures that the animation frames are synchronized with the browser's refresh rate.

  • Game loops: For game development, requestAnimationFrame() provides a reliable way to update and render game frames at a consistent rate.

  • Real-time data updates: When periodically fetching and updating data from an API or server, requestAnimationFrame() can be used to refresh the data display at a regular interval.

In conclusion, requestAnimationFrame() is a powerful method for calling a function every second in JavaScript. Its optimized performance, synchronization with the browser's rendering, and battery-friendly nature make it an ideal choice for animations, game loops, and real-time data updates.


In this article, we explored different methods for calling a function every second in JavaScript.

We first discussed the setInterval() function, which allows us to repeatedly execute a function at a specified interval. We learned about its syntax and arguments and saw an example code snippet demonstrating its usage.

Next, we explored an alternative approach using the setTimeout() function and recursion. By setting a timeout and recursively calling the function, we achieved a similar effect to setInterval(). We provided an example code snippet to illustrate this method.

We then compared the setInterval() and setTimeout() methods, highlighting their respective pros and cons. It is important to consider factors such as accuracy, performance, and the need for precise timing when choosing the appropriate method for periodic function calls.

Lastly, we introduced the requestAnimationFrame() method, which is commonly used for smooth animations but can also be leveraged to create timers. We discussed its benefits and use cases in calling a function every second.

Periodically calling a function in JavaScript is useful for a variety of applications, such as updating real-time data, refreshing content, and implementing timers or countdowns. By understanding the different methods available, developers can choose the most suitable approach based on their specific needs.

Overall, the ability to call a function every second in JavaScript provides flexibility and control in creating dynamic and interactive web applications.