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

Creating a 5-Second Delay in JavaScript


Timing is an essential aspect of code execution, particularly in JavaScript, where asynchronous and event-driven programming is common. Being able to control the timing of certain actions can greatly enhance the functionality and user experience of a web application.

There are several approaches to introducing a delay in JavaScript, each with its own advantages and use cases. In this blog post, we will explore four different methods for creating a 5-second delay in JavaScript: using the setTimeout function, employing the setInterval function, leveraging Promises, and utilizing async/await.

By the end of this blog post, you will have a comprehensive understanding of each method and be able to choose the one that best suits your specific timing requirements.

Now, let's dive into the details of each approach and see how they can be used to create a 5-second delay in JavaScript.

Using setTimeout Function

The setTimeout function is a built-in JavaScript function that allows you to introduce a delay in the execution of code. It takes two parameters: a callback function and a delay time in milliseconds.

To create a 5-second delay using setTimeout, you can pass a callback function and a delay of 5000 milliseconds (5 seconds) as arguments. The callback function will be executed after the specified delay.

setTimeout(function() {
  // code to be executed after 5 seconds
}, 5000);

The callback function plays a crucial role in setTimeout. It is the code that will be executed after the specified delay. You can define any code you want to run after the delay inside the callback function.

It is important to note that setTimeout is an asynchronous function, meaning that it does not block the execution of the rest of your code. This allows other operations to continue while waiting for the delay to complete.

However, there are some potential drawbacks or limitations to using setTimeout. One limitation is that the delay time is not always guaranteed to be exact. Factors such as the browser's event loop and the current system load can affect the accuracy of the delay. Additionally, if the code inside the callback function takes a significant amount of time to execute, it can cause delays in subsequent code execution. Therefore, it is important to be mindful of the potential impact on the overall performance of your code when using setTimeout.

Employing setInterval Function

The setInterval function in JavaScript is used to repeatedly execute a given function at a specified interval. It differs from setTimeout in that it continues to execute the function indefinitely until it is explicitly stopped.

To achieve a 5-second delay using setInterval, you can specify an interval of 5000 milliseconds (5 seconds) and provide the function you want to execute as the first parameter. Here's an example:

const intervalId = setInterval(() => {
  // Code to be executed every 5 seconds
}, 5000);

When using setInterval, it's important to note that the interval will keep running until it is stopped. To stop the interval, you can use the clearInterval function and pass the interval ID returned by setInterval as its parameter:


It's worth considering that the behavior of setInterval can be affected by the performance of the device or browser. If the execution of the function takes longer than the specified interval, the next execution will be delayed. This can result in irregular timing if there are other tasks or heavy computations running in parallel.

Additionally, be cautious when using setInterval for precise timing purposes, as it may not always provide accurate results. It's better suited for scenarios where you need a repeated execution at a certain interval, but exact timing is not critical.

In the next section, we will explore another approach to creating a 5-second delay using Promises.

Leveraging Promises

Promises play a crucial role in asynchronous JavaScript, allowing for better control over timing and execution. By utilizing Promises, we can create a delayed execution in our code.

To create a Promise with a 5-second delay, we can make use of the setTimeout function inside the Promise constructor. The setTimeout function takes two parameters: a callback function and a duration in milliseconds. By wrapping the setTimeout function inside a Promise, we can resolve the Promise after the specified delay.

Here's an example of creating a Promise with a 5-second delay:

function delay(ms) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);

delay(5000).then(() => {
  console.log('Delay of 5 seconds complete.');

In this example, the delay function returns a Promise that resolves after the specified delay of 5000 milliseconds (5 seconds). We can then use the then method to specify the code to be executed after the delay.

Using Promises for timing in JavaScript offers several benefits. Firstly, Promises provide a more structured and readable way to handle asynchronous operations compared to callbacks. They allow for easier chaining of multiple asynchronous tasks and error handling using the catch method. Additionally, Promises can be combined with other Promise-based functions, such as Promise.all or Promise.race, to create more complex timing scenarios.

By leveraging Promises, we can introduce a 5-second delay in our JavaScript code with ease and take advantage of the benefits they offer in terms of control and readability.

Utilizing async/await

Async/await is a modern JavaScript feature that simplifies asynchronous programming by allowing us to write asynchronous code in a synchronous-like manner. It is built on top of Promises and provides a more readable and structured way to handle asynchronous operations.

To introduce a 5-second delay using async/await, we can wrap the delay functionality in an async function and use the await keyword along with a setTimeout Promise. Here's an example:

async function delay() {
  await new Promise(resolve => setTimeout(resolve, 5000));
  console.log("5 seconds have passed");


In the above code, we define an async function called delay that wraps the delay functionality. Inside the function, we use the await keyword to pause the execution until the setTimeout Promise resolves after 5 seconds. Once the delay is over, the code inside the async function resumes execution and logs the message "5 seconds have passed" to the console.

One of the advantages of using async/await over traditional async coding techniques, such as using callbacks or Promises directly, is the improved readability and maintainability of the code. Async/await allows us to write asynchronous code that looks more like synchronous code, making it easier to understand and reason about.

However, it's important to note that async/await can only be used within functions marked with the async keyword. Additionally, using await inside a loop or a large number of asynchronous operations may impact performance, as it will pause the execution of the function until the awaited Promise resolves.

Overall, async/await provides a powerful and elegant way to introduce delays and handle asynchronous operations in JavaScript, offering improved readability and maintainability.


In this article, we explored different approaches to creating a 5-second delay in JavaScript. We discussed four methods: using the setTimeout function, employing the setInterval function, leveraging Promises, and utilizing async/await.

Each method has its advantages and limitations. The setTimeout function is simple to use and allows for executing code after a specified delay. However, it is a one-time delay and may not be suitable for scenarios requiring repeated delays.

The setInterval function, on the other hand, is useful for executing code at regular intervals. It can be used to achieve a 5-second delay by stopping the interval after the desired delay. However, it may not be the best choice for precise timing.

Promises provide a more elegant solution for delayed execution in JavaScript. They allow for chaining actions and handling both success and error cases, making code more readable and maintainable.

The async/await syntax builds upon Promises and offers a more synchronous way of writing asynchronous code. It simplifies the process of creating a 5-second delay by using the await keyword with a Promise.

To deepen your understanding and further explore these timing techniques, I encourage you to experiment with each method and see which one suits your specific needs. Remember to consider factors such as precision, readability, and maintainability when choosing the right approach.

If you want to learn more about JavaScript timing, I recommend checking out the Mozilla Developer Network (MDN) documentation on setTimeout, setInterval, Promises, and async/await. These resources provide detailed explanations, examples, and additional insights into JavaScript timing techniques.