Skip to main content

How to Round a Date to the Nearest Hour or Minute in JavaScript

When working with time-based data, you often need to "snap" a Date object to a specific interval, such as the nearest hour, 30 minutes, or 15 minutes. This is useful for creating time slots, grouping data into intervals, or standardizing timestamps. While JavaScript's Date object doesn't have a built-in round() method, you can easily create this functionality with some simple arithmetic on the date's timestamp.

This guide will teach you how to create a single, powerful, reusable function that can round a Date object to any given interval of minutes.

The Core Method: Rounding with Milliseconds​

The most effective way to round a date is to work with its underlying value: the timestamp in milliseconds.

Logic:

  1. Calculate the interval in milliseconds: For example, 15 minutes is 15 * 60 * 1000 milliseconds.
  2. Get the date's timestamp: Use date.getTime() to get the total milliseconds since the Unix Epoch.
  3. Perform the rounding: Divide the date's timestamp by the interval, round the result to the nearest whole number using Math.round(), and then multiply it back by the interval. This "snaps" the timestamp to the nearest interval boundary.
  4. Create a new Date: Create a new Date object from the rounded timestamp.

The Solution: A Reusable roundToNearestMinutes Function​

This single function can handle all of your date rounding needs. It is non-mutating, meaning it returns a new Date object and does not change the original.

/**
 * Rounds a Date object to the nearest specified number of minutes.
 * @param {Date} date - The original date to round.
 * @param {number} minutes - The interval to round to (e.g., 15, 30, 60).
 * @returns {Date} A new, rounded Date object.
 */
function roundToNearestMinutes(date, minutes) {
  let ms = 1000 * 60 * minutes; // Convert minutes to milliseconds
  
  // Create a new Date object from the rounded timestamp
  return new Date(Math.round(date.getTime() / ms) * ms);
}

How the Function Works​

Let's break down the key line: new Date(Math.round(date.getTime() / ms) * ms);

Imagine we are rounding 10:37 to the nearest 30 minutes (ms = 1,800,000).

  1. date.getTime(): Returns the timestamp, e.g., 1698399420000.
  2. / ms: The timestamp is divided by the 30-minute interval, resulting in a floating-point number, e.g., 943555.2333. This number represents how many 30-minute intervals have passed since the epoch.
  3. Math.round(...): This rounds the value to the nearest whole number, 943555. This is the "snapping" step.
  4. * ms: We multiply the rounded number back by the interval in milliseconds, e.g., 943555 * 1800000 = 1698399000000. This is the new, rounded timestamp, which corresponds exactly to 10:30.
  5. new Date(...): A new Date object is created from this clean timestamp.

Practical Examples​

With our reusable function, rounding to any interval is simple.

How to Round to the Nearest Hour (60 Minutes)​

To round to the nearest hour, you use an interval of 60 minutes.

let date1 = new Date('2025-10-25T10:29:00');  // Will round down
let date2 = new Date('2025-10-25T10:30:00');  // Will round up

let rounded1 = roundToNearestMinutes(date1, 60);
let rounded2 = roundToNearestMinutes(date2, 60);

console.log(rounded1.toLocaleTimeString());   // Output: 10:00:00 AM
console.log(rounded2.toLocaleTimeString());   // Output: 11:00:00 AM

How to Round to the Nearest 30 Minutes​

let date1 = new Date('2025-10-25T10:14:00');  // Will round down to 10:00
let date2 = new Date('2025-10-25T10:15:00');  // Will round up to 10:30

let rounded1 = roundToNearestMinutes(date1, 30);
let rounded2 = roundToNearestMinutes(date2, 30);

console.log(rounded1.toLocaleTimeString());   // Output: 10:00:00 AM
console.log(rounded2.toLocaleTimeString());   // Output: 10:30:00 AM

How to Round to the Nearest 15 Minutes​

let date1 = new Date('2025-10-25T10:07:29');  // Will round down to 10:00
let date2 = new Date('2025-10-25T10:07:30');  // Will round up to 10:15

let rounded1 = roundToNearestMinutes(date1, 15);
let rounded2 = roundToNearestMinutes(date2, 15);

console.log(rounded1.toLocaleTimeString());   // Output: 10:00:00 AM
console.log(rounded2.toLocaleTimeString());   // Output: 10:15:00 AM

Rounding Up vs. Rounding Down​

The roundToNearestMinutes function uses Math.round(), which rounds to the nearest interval. If you need to always round up or down, you can simply replace Math.round() with Math.ceil() or Math.floor().

  • Round Up (Ceiling): Always snap to the next interval. return new Date(Math.ceil(date.getTime() / ms) * ms);
  • Round Down (Floor): Always snap to the previous interval. return new Date(Math.floor(date.getTime() / ms) * ms);

Conclusion​

Rounding a Date object in JavaScript is a simple and powerful task once you understand the underlying timestamp arithmetic.

  • The recommended best practice is to create a reusable function that operates on the date's millisecond timestamp.
  • The core logic is to divide, round, and multiply the timestamp by your desired interval in milliseconds.
  • Use Math.round() to round to the nearest interval, Math.ceil() to always round up, and Math.floor() to always round down.
  • This approach is immutable (creates a new Date object) and can handle any minute-based interval, making it highly flexible.

Table of Contents