Skip to main content

How to Add Years to a Date in JavaScript

Calculating future or past dates by adding or subtracting years is a common requirement in programming. This is essential for determining anniversaries, expiration dates, or future milestones. The native JavaScript Date object provides a simple and direct way to perform this arithmetic using its getFullYear() and setFullYear() methods.

This guide will teach you the standard, immutable method for adding years to a Date object, ensuring your code is both accurate and free of side effects. We will also cover the important edge case of how the Date object handles leap years.

The Core Method: getFullYear() and setFullYear()​

The logic for adding years is straightforward:

  1. Use date.getFullYear() to get the current four-digit year as a number.
  2. Add the desired number of years to this number.
  3. Use date.setFullYear() to set the new year on the Date object.

The setFullYear() method is smart enough to handle all date components correctly, preserving the month, day, and time.

It is a strong best practice to write immutable functions for date manipulation. This means your function should not change the original Date object but should instead return a new one with the updated value.

For example, you have a Date object and you want to get a new Date object that is N years in the future.

// Problem: How to get a new Date object representing 5 years after this one?
const startDate = new Date('2025-10-15');

The solution is to define a function that creates a copy of the date before modifying it, preserving the original.

function addYears(date, years) {
  // Create a new Date object from the provided date to avoid mutation
  const dateCopy = new Date(date);
  
  // Set the new year
  dateCopy.setFullYear(date.getFullYear() + years);
  
  return dateCopy;
}

// Example Usage:
const startDate = new Date('2025-10-15');
const futureDate = addYears(startDate, 5);

console.log('Original Date:', startDate.toLocaleDateString('en-CA'));
console.log('Future Date:  ', futureDate.toLocaleDateString('en-CA'));

Output:

Original Date: 2025-10-15
Future Date:   2030-10-15

A Critical Edge Case: Leap Years (February 29th)​

A classic "gotcha" in date arithmetic is handling leap years. What happens if you add one year to February 29th? The next year does not have a February 29th.

The JavaScript Date object handles this by "overflowing" to the next available day, which is March 1st.

Example:

const leapDay = new Date('2024-02-29'); // 2024 is a leap year

// Add 1 year. 2025 is not a leap year.
const nextYear = addYears(leapDay, 1);

// The date "overflows" from the non-existent Feb 29, 2025 to Mar 1, 2025
console.log(nextYear.toLocaleDateString('en-CA'));

Output:

2025-03-01
note

This is the standard, predictable behavior of the Date object, and it's important to be aware of it when performing year-based calculations.

A Note on Mutability: Why You Shouldn't Change the Original Date​

You will often see examples that modify the original Date object directly.

The mutable approach is not recommended:

function addYears(date, years) {
  // ⛔️ This changes the original date object!
  date.setFullYear(date.getFullYear() + years);
  return date;
}
note

This is considered a bad practice because it creates a side effect. If you pass a Date variable to this function, that variable will be permanently changed, which can lead to unexpected bugs elsewhere in your application. Always prefer the immutable approach of creating a copy first.

Conclusion​

Adding years to a Date in JavaScript is a simple task using the built-in .getFullYear() and .setFullYear() methods.

  • The recommended best practice is to create a reusable and immutable function that:
    1. Makes a copy of the input Date object.
    2. Calls dateCopy.setFullYear(dateCopy.getFullYear() + years).
    3. Returns the new Date object.
  • Be aware of the leap year overflow behavior: adding a year to February 29th will result in March 1st in a non-leap year.
  • Avoid mutating the original Date object directly, as this can lead to unpredictable side effects.

Table of Contents