Skip to main content

How to Subtract Months from a Date in JavaScript

Calculating a date a certain number of months in the past is a common requirement in applications that deal with subscriptions, reporting periods, or historical data. The native Date object in JavaScript provides simple methods to handle this, automatically managing complex edge cases like year rollovers.

This guide will teach you the modern, standard method for subtracting months from a Date object in an immutable way, which is a crucial best practice to avoid bugs in your code. We will also cover how the Date object handles month-end date complexities.

The Core Problem: Date Objects are Mutable​

A critical concept to understand is that Date objects in JavaScript are mutable. Methods like setMonth() modify the original Date object in place. Modifying objects or parameters directly can lead to unexpected side effects and bugs that are hard to track down.

Example of problem in which original date is mutated:

function subtractMonths(date, months) {
  date.setMonth(date.getMonth() - months);
  return date;
}

const originalDate = new Date('2025-10-27');
const newDate = subtractMonths(originalDate, 2);

console.log(newDate.toISOString());         // Output: 2025-08-26T23:00:00.000Z
console.log(originalDate.toISOString());    // Output: 2025-08-26T23:00:00.000Z (The original was changed!)
note

This is often not the desired behavior. The best practice is to always create a copy of the date before performing any modifications.

The Solution: A Non-Mutating Function​

The correct and safe way to subtract months is to first create a copy of the date and then modify the copy. This is known as an immutable operation.

This function creates a new Date object, ensuring the original remains unchanged.

/**
 * Returns a new Date object with the specified number of months subtracted.
 * @param {Date} date - The original date.
 * @param {number} months - The number of months to subtract.
 * @returns {Date} A new Date object.
 */
function subtractMonths(date, months) {
  const dateCopy = new Date(date);
  dateCopy.setMonth(date.getMonth() - months);
  return dateCopy;
}

// Example Usage:
const originalDate = new Date('2025-10-27');

// Subtract 3 months from the original date
const newDate = subtractMonths(originalDate, 3);

console.log('Original Date:', originalDate.toLocaleDateString());
console.log('New Date:     ', newDate.toLocaleDateString());

Output:

Original Date: 27/10/2025
New Date:      27/07/2025
note

By creating a dateCopy, we ensure our function is "pure"—it doesn't have side effects and will always return a new date without altering the original.

How setMonth() Handles Date Logic​

The power of this operation lies in the setMonth() method. It is smart enough to handle all date calculations for you, including rolling back to the previous year.

  • date.getMonth(): Gets the month as a zero-based number (0 for January, 11 for December).
  • date.setMonth(month): Sets the month.

When you pass a number that is less than 0, setMonth() automatically adjusts the year.

// Example: Crossing a year boundary
const january2023 = new Date('2025-01-15');

// Subtracting 2 months from January
january2023.setMonth(january2023.getMonth() - 2); // 0 - 2 = -2

// The Date object correctly rolls back to November of the previous year
console.log(january2023.toLocaleDateString()); // Output: 15/11/2024

Output:

15/11/2024

Important Edge Case: Handling Month-End Dates​

A tricky situation arises when you subtract months from a date at the end of a month that has more days than the destination month. For example, what is 1 month before March 31st? February 31st doesn't exist.

The Date object handles this by "rolling over." If the resulting day is invalid for the new month, it rolls forward into the next month.

Example of problem:

const march31 = new Date('2025-03-31');

// Subtracting 1 month (0-indexed: month 2 -> month 1)
const result = subtractMonths(march31, 1);

// It tries to create February 31st, which doesn't exist.
// February has 28 days in 2025, so it rolls forward 3 days into March.
// Feb 28 -> Mar 1 -> Mar 2 -> Mar 3
console.log(result.toLocaleDateString()); // Output: 03/03/2023 (This may be unexpected!)

Solution: If you need to ensure the date always lands on the last day of the month, you must add extra logic to detect this rollover. However, for most use cases, understanding this default rollover behavior is sufficient.

Conclusion​

Subtracting months from a Date in JavaScript is simple and reliable, as long as you follow the best practice of immutability.

  • Always create a copy of your Date object before modifying it to avoid unexpected side effects: const dateCopy = new Date(originalDate);.
  • Use the dateCopy.setMonth(dateCopy.getMonth() - months) pattern to perform the subtraction. The Date object will automatically handle year rollovers.
  • Be aware of the month-end rollover behavior when subtracting from dates like the 31st of a month.

Table of Contents