Introduction

Dealing with dates and time in JavaScript can feel tricky, even for experienced developers. Ever wondered why sometimes your new Date() output seems off by a few hours? Or why JavaScript thinks time started only in 1970?

In this ariticle, we’ll take a deep dive into everything about JavaScript dates — from the basics of creating and displaying dates to advanced concepts like time zones, formatting, and working with timestamps. By the end, you’ll be comfortable manipulating dates in JavaScript and understanding exactly what happens behind the scenes.

Exploring the JavaScript Date Object

In JavaScript, the Date() is the primary tool for woking with Dates and Times. Internally, JavaScript stores all dates as the number of milliseconds since January 1, 1970, 00:00:00 UTC.

Why 1 January 1970 only?

JavaScript adopted this approch from the UNIX. Here all the date calculations based on the UTC (Universal Time Coordinates). Js stores the date and time in milliseconds from 1 January 1970 and when you display it converts to local time zone based on the non sensitive data or offsets provide by your browser or OS.

Note: UTC is often used as global timestamps, because it is same everywhre.

What are the various methods to define a Date?

There are several ways to create a Date( )

// 1. Current date and time
const now = new Date();
console.log(now); // e.g., 2025-10-08T04:15:23.456Z

// 2. Using a timestamp (milliseconds since 1970-01-01 UTC)
const epochDate = new Date(0);
console.log(epochDate.toUTCString()); // Thu, 01 Jan 1970 00:00:00 GMT

// 3. Using date strings
const dateString = new Date("2025-10-08T12:00:00Z");
console.log(dateString.toISOString()); // 2025-10-08T12:00:00.000Z

// 4. Using components: year, month, day, hour, minute, second
const componentsDate = new Date(2025, 9, 8, 12, 0, 0); // Month is 0-based
console.log(componentsDate.toString()); // Wed Oct 08 2025 12:00:00 GMT+0530 (India Standard Time)

Pro Tip: When using the constructor with components (new Date(year, month, day, ...)) remember that months are zero-indexed — January is 0, December is 11.

Getting the Current Timestamp

JavaScript provides a simple method to get the current time in milliseconds since the Unix epoch:

const timestamp = Date.now();
console.log(timestamp); // e.g., 1728359200123

You can also convert this timestamp back into a readable date:

const dateFromTimestamp = new Date(timestamp);
console.log(dateFromTimestamp.toString());

Why This Matters?

Understanding that JavaScript stores dates in UTC milliseconds is crucial because:

It explains why Date outputs can differ based on your system timezone.
It makes it easier to calculate differences between dates.
It prepares you to handle time zones and date formatting correctly and efficiently.

What are the comman methods of Date?

Once a Date object, JavaScript provides a various built-in methods to read and modify specific parts of it — like the year, month, day, hours, and more.

const date = new Date();

console.log("Year:", date.getFullYear());
console.log("Month:", date.getMonth()); // 0-based
console.log("Date:", date.getDate());
console.log("Day:", date.getDay()); // 1-based (Mon, Tue, Wed...)
console.log("Hour:", date.getHours());
console.log("Minutes:", date.getMinutes());
console.log("Seconds:", date.getSeconds());
console.log("Milliseconds:", date.getMilliseconds());
console.log("Timestamp:", date.getTime());

Above are the js date and time components. But, apart from this there are lot’s of usefull methods available for fomatting and conversion is thre. Some of most commonly used methods is given below:

// Create a new date object
const date = new Date("2025-10-08T04:45:00Z");

console.log("Original Date (UTC):", date);

// 1. toString()
// Converts to a local time string (based on your system timezone)
console.log("toString():", date.toString());
// Example output: "Wed Oct 08 2025 10:15:00 GMT+0530 (India Standard Time)"

// 2. toUTCString()
// Converts to a human-readable string in UTC format
console.log("toUTCString():", date.toUTCString());
// Example output: "Wed, 08 Oct 2025 04:45:00 GMT"

// 3. toISOString()
// Converts to ISO 8601 format (always UTC, standardized)
console.log("toISOString():", date.toISOString());
// Example output: "2025-10-08T04:45:00.000Z"

// 4. toDateString()
// Returns only the date part (ignores time)
console.log("toDateString():", date.toDateString());
// Example output: "Wed Oct 08 2025"

// 5. toTimeString()
// Returns only the time part (local time)
console.log("toTimeString():", date.toTimeString());
// Example output: "10:15:00 GMT+0530 (India Standard Time)"

// 6. toLocaleString()
// Converts based on your system locale and timezone
console.log("toLocaleString():", date.toLocaleString());
// Example output (India): "10/8/2025, 10:15:00 AM"
// Example output (US): "10/7/2025, 10:15:00 PM"

Manipulating Dates in JavaScript

The JavaScript Date object doesn’t have built-in functions like addDays() or subtractHours() —
but you can easily do these operations using milliseconds or set/get methods.

1. Adding or Subtracting Days

Since one day = 86,400,000 milliseconds (24 × 60 × 60 × 1000),
you can shift a date forward or backward using this logic.

const date = new Date("2025-10-08");

// Add 5 days
const addDays = new Date(date);
addDays.setDate(date.getDate() + 5);

console.log("Original:", date.toDateString());
console.log("After Adding 5 Days:", addDays.toDateString());

// Subtract 3 days
const subtractDays = new Date(date);
subtractDays.setDate(date.getDate() - 3);

console.log("After Subtracting 3 Days:", subtractDays.toDateString());

Output:

Original: Wed Oct 08 2025
After Adding 5 Days: Mon Oct 13 2025
After Subtracting 3 Days: Sun Oct 05 2025

2. Adding Hours, Minutes, or Seconds

Similarly, you can manipulate smaller time units using the respective setter methods.

const date = new Date("2025-10-08T10:00:00");

date.setHours(date.getHours() + 2);     // Add 2 hours
date.setMinutes(date.getMinutes() - 30); // Subtract 30 minutes

console.log(date.toString());

Example output:

Wed Oct 08 2025 11:30:00 GMT+0530 (India Standard Time)

3. Calculating Time Difference Between Two Dates

You can find the difference between two dates in milliseconds and then convert it to days, hours, or minutes.

const start = new Date("2025-10-01");
const end = new Date("2025-10-08");

const diffInMs = end - start; // difference in milliseconds
const diffInDays = diffInMs / (1000 * 60 * 60 * 24);

console.log(`Difference: ${diffInDays} days`);

Output:

Difference: 7 days

4. Comparing Dates

Comparing dates is straightforward since JavaScript can compare them numerically:

const d1 = new Date("2025-10-01");
const d2 = new Date("2025-10-08");

if (d1 < d2) {
  console.log("d1 comes before d2");
} else if (d1 > d2) {
  console.log("d1 comes after d2");
} else {
  console.log("Both dates are the same");
}

5. Cloning a Date (Important!)

If you directly modify a date, it changes the original object.
To avoid this, always clone your date before modifying:

const date1 = new Date("2025-10-08");
const date2 = new Date(date1); // clone

date2.setDate(date2.getDate() + 10);

console.log("Original:", date1.toDateString());
console.log("Modified:", date2.toDateString());

6. Converting Between Date and Timestamp

Sometimes you’ll need to work with timestamps for APIs or databases:

const now = new Date();

// Convert to timestamp
const timestamp = now.getTime();
console.log("Timestamp:", timestamp);

// Convert back to date
const fromTimestamp = new Date(timestamp);
console.log("Converted Back:", fromTimestamp.toString());

Summary

JavaScript dates revolve around UTC time since Jan 1, 1970, but display and behave based on your local timezone.
You can easily create, modify, and format dates using built-in methods like getDate(), setHours(), toISOString(), and toLocaleString().

Key Points:

Always store dates in UTC, display in local time.
Use Intl.DateTimeFormat or toLocaleString() for readable formats.
Manipulate safely using get/set methods and clone before editing.

Master these essentials, and you’ll handle any time-related logic in JavaScript with confidence.

Mastering JavaScript Dates: From Basics to Advanced Concepts