How to Get a Timestamp in JavaScript: A Complete Guide

In JavaScript, getting the current timestamp—a numeric representation of the current date and time—is straightforward but offers flexibility based on the desired precision and compatibility. This guide will walk you through methods to get a timestamp, both in milliseconds (common in JavaScript) and seconds (standard in Unix and often preferred in cross-language contexts).

1. Getting the Timestamp in Milliseconds

JavaScript has a built-in method for fetching the current timestamp in milliseconds: Date.now(). This is a simple and modern way to get the time since the Unix epoch (January 1, 1970, at midnight UTC):

let timestampMs = Date.now();
console.log(timestampMs); // e.g., 1632159274427

If you prefer alternatives, you can get the same result by creating a new Date object and calling .getTime():

let timestampMs = new Date().getTime();
console.log(timestampMs); // e.g., 1632159274427

Or, for a shorter syntax, use the unary + operator with new Date():

let timestampMs = +new Date();
console.log(timestampMs);

2. Getting the Timestamp in Seconds

Many applications require timestamps in seconds instead of milliseconds. You can convert the millisecond timestamp to seconds by dividing by 1000 and rounding down.

let timestampSec = Math.floor(Date.now() / 1000);
console.log(timestampSec); // e.g., 1632159274

An alternative that achieves the same result but with a bitwise OR operation (slightly faster but less readable):

let timestampSec = Date.now() / 1000 | 0;
console.log(timestampSec);

Note: The bitwise OR (|) operation works similarly to Math.floor() but truncates the decimal. However, using bitwise operations could lead to compatibility issues with future timestamps if JavaScript moves fully to 64-bit integers.

3. High-Resolution Timestamps Using performance.now()

If you need even higher precision, performance.now() offers a fractional millisecond timestamp, which is helpful for performance measurement. This method returns the number of milliseconds (including fractions) since the page loaded.

let highResTimestamp = performance.now();
console.log(highResTimestamp); // e.g., 1432.563433

To make this high-resolution timestamp comparable to Date.now(), add the navigationStart time:

let accurateTimestamp = performance.now() + performance.timing.navigationStart;
console.log(accurateTimestamp);

4. Ensuring Compatibility with Older Browsers

For environments that don’t support Date.now(), like Internet Explorer 8, you can use a polyfill. This allows Date.now() to be used everywhere:

if (!Date.now) {
  Date.now = function() { return new Date().getTime(); };
}

With this snippet, Date.now() will behave as expected across browsers, even in legacy environments.

5. Relative Time Tracking Using Closures

Sometimes you need to measure elapsed time since a specific point. A relative timer is a great way to do this and can be set up with a closure:

const relativeTimer = (() => {
  const start = Date.now();
  return () => Date.now() - start;
})();

console.log(relativeTimer()); // time in ms since relativeTimer was created

This approach is helpful in performance testing or any scenario where tracking time since an event is required.

6. Alternative Methods for Quick Timestamps

Here are some other ways to get timestamps quickly in JavaScript, depending on your preferences:

Using the Number Constructor

let timestamp = Number(new Date());
console.log(timestamp); // e.g., 1632159274427

jQuery’s $.now()

If you’re using jQuery, it offers an alternative timestamp method, $.now(), which is equivalent to Date.now():

let timestamp = $.now();
console.log(timestamp);

Summary of Methods

Each method provides a different approach depending on your specific needs for precision, readability, and compatibility:

Method	Description	Precision
Date.now()	Standard, most efficient method	Milliseconds
new Date().getTime()	Equivalent to Date.now()	Milliseconds
+new Date()	Short and compact	Milliseconds
Math.floor(Date.now()/1000)	Converts to Unix timestamp	Seconds
performance.now()	High-resolution, fractional milliseconds	Sub-milliseconds

For most cases, Date.now() is the best choice—it’s simple, modern, and provides reliable results. However, you have several alternatives at your disposal, whether you need high-resolution precision or backwards compatibility.