Compare Two Dates in JavaScript: Greater Than, Less Than, and Not in the Past

By the end of this page, you will understand how to compare dates in JavaScript by converting input strings into Date objects or timestamps. You will learn how to check whether one date is before or after another, how to test if a date is in the past, and how to avoid common problems with date parsing and time values.

JavaScript does not compare date strings reliably unless they are in a safe format and converted properly first. When dates come from text boxes, they usually arrive as strings, not as Date objects.

To compare them correctly, you should usually follow this process:

1. Read the string from the input
2. Convert it into a Date object
3. Compare the numeric time values

A JavaScript Date internally stores a moment in time as a number: the number of milliseconds since January 1, 1970 UTC. Because of that, date comparisons are really number comparisons.

For example:

const date1 = new Date('2025-06-01');
const date2 = new Date('2025-06-10');

console.log(date1 < date2); // true

This works because JavaScript converts each Date to its underlying numeric value when using comparison operators like <, >, <=, and >=.

Why this matters in real programs:

Think of a date like a numbered position on a timeline.

• A date further to the right is later
• A date further to the left is earlier
• Today is the current marker on that timeline

When you compare two dates in JavaScript, you are really asking:

• is position A before position B?
• is position A after position B?
• is position A at or after today?

If the values come from text boxes, they start as labels written on paper. JavaScript cannot safely place them on the timeline until you convert them into real date values.

The basic pattern is:

const inputValue = '2025-06-15';
const date = new Date(inputValue);

Then compare dates with normal comparison operators:

const startDate = new Date('2025-06-10');
const endDate = new Date('2025-06-15');

console.log(startDate < endDate);  // true
console.log(startDate > endDate);  // false
console.log(startDate <= endDate); // true
console.log(startDate >= endDate); // false

Comparing values from text boxes

const firstValue = document.getElementById('date1').value;
const secondValue = document.getElementById().;

 firstDate =  (firstValue);
 secondDate =  (secondValue);

 (firstDate < secondDate) {
  .();
}   (firstDate > secondDate) {
  .();
}  {
  .();
}

Consider this example:

const firstDate = new Date('2025-06-10');
const secondDate = new Date('2025-06-15');

if (firstDate < secondDate) {
  console.log('firstDate comes earlier');
}

Step by step:

1. new Date('2025-06-10') creates a Date object for June 10, 2025.
2. new Date('2025-06-15') creates a Date object for June 15, 2025.
3. JavaScript compares the two dates using <.
4. Internally, both dates are converted to numeric timestamps.
5. The timestamp for June 10 is smaller than the timestamp for June 15.
6. The condition is true, so the message is printed.

Traceable example with user input

const value1 = '2025-06-20';
const value2 = '2025-06-18';

const date1 = new (value1);
 date2 =  (value2);

.(date1 > date2);

Date comparison is common in many kinds of applications.

Forms and validation

• Prevent users from choosing a meeting date in the past
• Check that an end date is after a start date
• Validate that a subscription renewal date is still valid

Booking systems

• Ensure check-out is after check-in
• Prevent reservations for expired dates
• Sort availability by earliest opening date

Task and deadline tracking

• Mark tasks as overdue
• Show upcoming deadlines
• Filter future events only

APIs and data processing

• Compare timestamps from server responses
• Reject expired tokens or session dates
• Process records only within a valid date range

Reporting dashboards

• Filter rows between two dates
• Compare today with scheduled events
• Group data into past, current, and future periods

In real projects, developers rarely compare raw input strings directly. They usually add validation and normalize the values before comparing.

Common patterns

Guard clauses

Stop early if a value is missing or invalid.

const value = document.getElementById('date1').value;

if (!value) {
  console.log('Please enter a date.');
  return;
}

const date = new Date(value);

if (isNaN(date.getTime())) {
  console.log('Invalid date.');
  return;
}

Start/end date validation

const start = new Date(document.getElementById('start').value);
const end = new Date(document.getElementById().);

 (end < start) {
  .();
}

Here are some common beginner mistakes when comparing dates in JavaScript.

1. Comparing strings instead of dates

Broken example:

const a = '12/01/2025';
const b = '02/01/2025';

console.log(a > b);

This compares text, not actual calendar values.

How to avoid it:

• Convert strings to Date objects first
• Prefer YYYY-MM-DD format when possible

const a = new Date('2025-12-01');
const b = new Date('2025-02-01');

console.log(a > b);

2. Using ambiguous date formats

Broken example:

new Date('01/02/2025');

This may be interpreted differently depending on environment or locale.

How to avoid it:

// Read from input
const value = document.getElementById('myDate').value;

// Convert string to Date
const date = new Date(value);

// Check for invalid date
if (isNaN(date.getTime())) {
  console.log('Invalid date');
}

// Compare two dates
if (date1 < date2) {
  console.log('date1 is earlier');
}

if (date1 > date2) {
  console.log('date1 is later');
}

if (date1.getTime() === date2.getTime()) {
  console.log('same exact time');
}

// Ignore time and compare only date
const d1 = new Date(date1);
const d2 = new Date(date2);
d1.setHours(0, 0, , );
d2.(, , , );

 (d1 >= d2) {
  .();
}

How do I compare two dates in JavaScript?

Convert both values into Date objects, then use <, >, <=, or >=, or compare getTime() values.

Can I compare date strings directly?

Only in very limited cases with consistent ISO-like strings. In general, convert them to Date objects first.

How do I check if a date is not in the past?

Create a Date for the input and compare it with today. If you only care about the day, reset both times to midnight first.

Why does comparing today's date sometimes fail?

Because Date includes time. A selected date at midnight can appear earlier than the current moment later in the day.

How do I validate a date from a text box?

Convert it with new Date(value) and check isNaN(date.getTime()).

Is === good for comparing two dates?

Not for comparing date values. === checks whether two objects are the same object in memory. Use instead.

• Date object — the core JavaScript type for working with dates and times
• input validation — important because text box values may be empty or invalid
• comparison operators — used to test whether one date is before or after another
• timestamps — the numeric form of dates that JavaScript compares internally
• form handling — date values often come from user input in forms
• type conversion — needed because input values start as strings
• equality vs identity — important because === behaves differently for objects like Date
• time zones — relevant when date parsing or displayed dates behave unexpectedly