How do I get a timestamp in JavaScript?

Question

I want a single number that represents the current date and time, like a Unix timestamp.

Glenine

Answer 1

Timestamp in milliseconds

To get the number of milliseconds since Unix epoch, call Date.now:

Date.now()

Alternatively, use the unary operator + to call Date.prototype.valueOf:

+ new Date()

Alternatively, call valueOf directly:

new Date().valueOf()

To support IE8 and earlier (see compatibility table), create a shim for Date.now:

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

Alternatively, call getTime directly:

new Date().getTime()

---

Timestamp in seconds

To get the number of seconds since Unix epoch, i.e. Unix timestamp:

Math.floor(Date.now() / 1000)

Alternatively, using bitwise-or to floor is slightly faster, but also less readable and may break in the future (see explanations 1, 2):

Date.now() / 1000 | 0

---

Timestamp in milliseconds (higher resolution)

Use performance.now:

var isPerformanceSupported = (
    window.performance &&
    window.performance.now &&
    window.performance.timing &&
    window.performance.timing.navigationStart
);

var timeStampInMs = (
    isPerformanceSupported ?
    window.performance.now() +
    window.performance.timing.navigationStart :
    Date.now()
);

console.log(timeStampInMs, Date.now());

Mixed

In case you wonder about the logic of plus sign is: + is used as toInt() where it will neglect all the characters and return only numbers – Roath

Or use an online tool: magictools.dev/#!/tools/timestamp-to-date – Deimos

Answer 2

I like this, because it is small:

+new Date

I also like this, because it is just as short and is compatible with modern browsers, and over 500 people voted that it is better:

Date.now()

Pterous

@Billy As I recall it, I computed the timestamp in the two suggested solutions 1M times each, and calculated the average runtime. I ran it in Firefox and Chrome, with getTime being faster in both browsers. That said, even if it were (marginally) slower I'd choose new Date().getTime(). Luckily for me, the faster solution is already the legible solution! – Hesiod

Agreed with @FabrícioMatté. Unary operator behavior may not be rudimentary, but if you haven't brushed up on it, don't expect to be able to function effectively in a lot of teams. – Gnawing

@Niklaus That's because you're concatenating it to another string. In that case, new Date().toString() is called. – Mert

+ is unary mathmatic in this case. typeof (+new Date()) evaluates to "number". Basically it's shorthand for new Date().valueOf() -- without the javascript function call. But don't write it this way, it looks like a typo. – Rhythmics

@Niklaus in that case you would need another plus to act as the unary operator: 'NEW-' + +new Date – Tema

The +new Date does not seem to work in Chrome 52, if the desired effect is to generate an integer. I am confident it worked on older Chromes. – Penman

@MarcusJohansson people should be using Date.now() if they are using a newer browser like Chrome. I tried this in Chrome 52 and Chrome Canary 55 and +new Date still worked. – Pterous

@FelixGagnon-Grenier I added Date.now() because it is now the preferred way, and lots of people don't like +new Date. I like that daveb's answer now includes +new Date, and explains it, but it didn't used to either. – Pterous

So to retrieve a numeric value that is already inside your computer you create an object, call an operator that requires an int and triggers a conversion that calls a function (valueOf) that calls the class conversion method that calls the function (getTime) that finally retrieves the value that was already there. Then the object is abandoned to its destiny, and after 1000 iterations of the loop you have 1000 deleted Date objects requiring garbage collection hanging there that suddenly get all dumped together, and while your computer lags you wonder what is happening. :) – Inharmonic

+0 for "and over 357 people voted that it's better" because we don't give votes for funny on SO. But +1 for good answer. And because it's funny. ;^) (I do get tired of "looks like a typo" complaints when it's a language feature. ~~ is a great truncate, but folks lodge the same complaint. But if it weren't there, someone'd invent it, you know? Learn the language, 357 people! It's fun.) – Toadstool

In case you wonder about the logic of plus sign is: + is used as toInt() where it will neglect all the characters and return only numbers – Roath

Answer 3

JavaScript works with the number of milliseconds since the epoch whereas most other languages work with the seconds. You could work with milliseconds but as soon as you pass a value to say PHP, the PHP native functions will probably fail. So to be sure I always use the seconds, not milliseconds.

This will give you a Unix timestamp (in seconds):

var unix = Math.round(+new Date()/1000);

This will give you the milliseconds since the epoch (not Unix timestamp):

var milliseconds = new Date().getTime();

Prismatic

I prefer this answer because it doesn't smuggle in the apparent bias for Math.floor(). Math.floor() can have a rounding inaccuracy of up to one second, whereas Math.round()'s inaccuracy approaches only half a second. I think the argument for Math.floor() is that it avoids a "now" timestamp that is technically slightly into the future. Why is that so egregious compared to a "now" timestamp that can be more in the past? Using Math.floor(), which is potentially more inaccurate, simply because it can't produce a "future" timestamp wreaks of over-thinking it. – Indoeuropean

Answer 4

I provide multiple solutions with descriptions in this answer. Feel free to ask questions if anything is unclear

---

Quick and dirty solution:

Date.now() /1000 |0

Warning: it might break in 2038 and return negative numbers if you do the |0 magic. Use Math.floor() instead by that time

Math.floor() solution:

Math.floor(Date.now() /1000);

---

Some nerdy alternative by Derek 朕會功夫 taken from the comments below this answer:

new Date/1e3|0

---

Polyfill to get Date.now() working:

To get it working in IE you could do this (Polyfill from MDN):

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

---

If you do not care about the year / day of week / daylight saving time you need to remember this for dates after 2038:

Bitwise operations will cause usage of 32 Bit Integers instead of 64 Bit Floating Point.

You will need to properly use it as:

Math.floor(Date.now() / 1000)

---

If you just want to know the relative time from the point of when the code was run through first you could use something like this:

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

---

In case you are using jQuery you could use $.now() as described in jQuery's Docs which makes the polyfill obsolete since $.now() internally does the same thing: (new Date).getTime()

If you are just happy about jQuery's version, consider upvoting this answer since I did not find it myself.

---

Now a tiny explaination of what |0 does:

By providing |, you tell the interpreter to do a binary OR operation.
Bit operations require absolute numbers which turns the decimal result from Date.now() / 1000 into an integer.

During that conversion, decimals are removed, resulting in a similar result to what using Math.floor() would output.

Be warned though: it will convert a 64 bit double to a 32 bit integer.
This will result in information loss when dealing with huge numbers.
Timestamps will break after 2038 due to 32 bit integer overflow unless Javascript moves to 64 Bit Integers in Strict Mode.

---

For further information about Date.now follow this link: Date.now() @ MDN

Anu

Answer 5

var time = Date.now || function() {
  return +new Date;
};

time();

Aeolotropic

Answer 6

var timestamp = Number(new Date()); // current time as number

Heretic

Answer 7

In addition to the other options, if you want a dateformat ISO, you can get it directly

console.log(new Date().toISOString());

Seaware

Answer 8

jQuery provides its own method to get the timestamp:

var timestamp = $.now();

^{(besides it just implements (new Date).getTime() expression)}

REF: http://api.jquery.com/jQuery.now/

Profile

Answer 9

Date, a native object in JavaScript is the way we get all data about time.

Just be careful in JavaScript the timestamp depends on the client computer set, so it's not 100% accurate timestamp. To get the best result, you need to get the timestamp from the server-side.

Anyway, my preferred way is using vanilla. This is a common way of doing it in JavaScript:

Date.now(); //return 1495255666921

In MDN it's mentioned as below:

The Date.now() method returns the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC.
Because now() is a static method of Date, you always use it as Date.now().

If you using a version below ES5, Date.now(); not works and you need to use:

new Date().getTime();

Fool

Thanks, I went through tons of answers all over the net and was getting to this conclusions but nobody to confirm it. – Interpellant

Answer 10

Performance

Today - 2020.04.23 I perform tests for chosen solutions. I tested on MacOs High Sierra 10.13.6 on Chrome 81.0, Safari 13.1, Firefox 75.0

Conclusions

• Solution Date.now() (E) is fastest on Chrome and Safari and second fast on Firefox and this is probably best choice for fast cross-browser solution
• Solution performance.now() (G), what is surprising, is more than 100x faster than other solutions on Firefox but slowest on Chrome
• Solutions C,D,F are quite slow on all browsers

Details

Results for chrome

You can perform test on your machine HERE

Code used in tests is presented in below snippet

function A() {
  return new Date().getTime();
}

function B() {
  return new Date().valueOf();
}

function C() {
  return +new Date();
}

function D() {
  return new Date()*1;
}

function E() {
  return Date.now();
}

function F() {
  return Number(new Date());
}

function G() {
  // this solution returns time counted from loading the page.
  // (and on Chrome it gives better precission)
  return performance.now(); 
}



// TEST

log = (n,f) => console.log(`${n} : ${f()}`);

log('A',A);
log('B',B);
log('C',C);
log('D',D);
log('E',E);
log('F',F);
log('G',G);

This snippet only presents code used in external benchmark

Krishnakrishnah

Answer 11

console.log(new Date().valueOf()); // returns the number of milliseconds since the epoch

Gamesome

Answer 12

Just to add up, here's a function to return a timestamp string in Javascript. Example: 15:06:38 PM

function displayTime() {
    var str = "";

    var currentTime = new Date()
    var hours = currentTime.getHours()
    var minutes = currentTime.getMinutes()
    var seconds = currentTime.getSeconds()

    if (minutes < 10) {
        minutes = "0" + minutes
    }
    if (seconds < 10) {
        seconds = "0" + seconds
    }
    str += hours + ":" + minutes + ":" + seconds + " ";
    if(hours > 11){
        str += "PM"
    } else {
        str += "AM"
    }
    return str;
}

Radarscope

Answer 13

One I haven't seen yet

Math.floor(Date.now() / 1000); // current time in seconds

Another one I haven't seen yet is

var _ = require('lodash'); // from here https://lodash.com/docs#now
_.now();

Benedictine

Answer 14

The Date.getTime() method can be used with a little tweak:

The value returned by the getTime method is the number of milliseconds since 1 January 1970 00:00:00 UTC.

Divide the result by 1000 to get the Unix timestamp, floor if necessary:

(new Date).getTime() / 1000

---

^{The Date.valueOf() method is functionally equivalent to Date.getTime(), which makes it possible to use arithmetic operators on date object to achieve identical results. In my opinion, this approach affects readability.}

Nephogram

Answer 15

The code Math.floor(new Date().getTime() / 1000) can be shortened to new Date / 1E3 | 0.

Consider to skip direct getTime() invocation and use | 0 as a replacement for Math.floor() function. It's also good to remember 1E3 is a shorter equivalent for 1000 (uppercase E is preferred than lowercase to indicate 1E3 as a constant).

As a result you get the following:

var ts = new Date / 1E3 | 0;

console.log(ts);

Disapproval

Answer 16

I highly recommend using moment.js. To get the number of milliseconds since UNIX epoch, do

moment().valueOf()

To get the number of seconds since UNIX epoch, do

moment().unix()

You can also convert times like so:

moment('2015-07-12 14:59:23', 'YYYY-MM-DD HH:mm:ss').valueOf()

I do that all the time. No pun intended.

To use moment.js in the browser:

<script src="moment.js"></script>
<script>
    moment().valueOf();
</script>

For more details, including other ways of installing and using MomentJS, see their docs

Boor

Answer 17

For a timestamp with microsecond resolution, there's performance.now:

function time() { 
  return performance.now() + performance.timing.navigationStart;
}

This could for example yield 1436140826653.139, while Date.now only gives 1436140826653.

Ozenfant

Documented to have millisecond resolution, not microsecond. Also performance.timing.navigationStart is deprecated. – Guardroom

Answer 18

Here is a simple function to generate timestamp in the format: mm/dd/yy hh:mi:ss

function getTimeStamp() {
    var now = new Date();
    return ((now.getMonth() + 1) + '/' +
            (now.getDate()) + '/' +
             now.getFullYear() + " " +
             now.getHours() + ':' +
             ((now.getMinutes() < 10)
                 ? ("0" + now.getMinutes())
                 : (now.getMinutes())) + ':' +
             ((now.getSeconds() < 10)
                 ? ("0" + now.getSeconds())
                 : (now.getSeconds())));
}

Pentheus

@b123400 - Here's the Lisp version: (new (chain (-date) (to-i-s-o-string))). – Phoneme

Answer 19

// The Current Unix Timestamp
// 1443534720 seconds since Jan 01 1970. (UTC)

// seconds
console.log(Math.floor(new Date().valueOf() / 1000)); // 1443534720
console.log(Math.floor(Date.now() / 1000)); // 1443534720
console.log(Math.floor(new Date().getTime() / 1000)); // 1443534720

// milliseconds
console.log(Math.floor(new Date().valueOf())); // 1443534720087
console.log(Math.floor(Date.now())); // 1443534720087
console.log(Math.floor(new Date().getTime())); // 1443534720087

// jQuery
// seconds
console.log(Math.floor($.now() / 1000)); // 1443534720
// milliseconds
console.log($.now()); // 1443534720087

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

Talebearer

Answer 20

You can only use

    var timestamp = new Date().getTime();
    console.log(timestamp);

to get the current timestamp. No need to do anything extra.

Stypsis

Answer 21

If it is for logging purposes, you can use ISOString

new Date().toISOString()

"2019-05-18T20:02:36.694Z"

Decennary

Answer 22

Any browsers not supported Date.now, you can use this for get current date time:

currentTime = Date.now() || +new Date()

Tlemcen

(Rephrasing my comment) Your code has a problem: it executes Date.now method instead of checking its support first. On older browsres it will cause Date.now is not a function error. – Nephogram

Perhaps a better alternative would be to use a ternary operator to assert that Date.now actually exists (and is a function), before attempting to invoke it: currentTime = typeof Date.now === "function" ? Date.now() : +new Date(). – Govan

Answer 23

This seems to work.

console.log(clock.now);
// returns 1444356078076

console.log(clock.format(clock.now));
//returns 10/8/2015 21:02:16

console.log(clock.format(clock.now + clock.add(10, 'minutes'))); 
//returns 10/8/2015 21:08:18

var clock = {
    now:Date.now(),
    add:function (qty, units) {
            switch(units.toLowerCase()) {
                case 'weeks'   :  val = qty * 1000 * 60 * 60 * 24 * 7;  break;
                case 'days'    :  val = qty * 1000 * 60 * 60 * 24;  break;
                case 'hours'   :  val = qty * 1000 * 60 * 60;  break;
                case 'minutes' :  val = qty * 1000 * 60;  break;
                case 'seconds' :  val = qty * 1000;  break;
                default       :  val = undefined;  break;
                }
            return val;
            },
    format:function (timestamp){
            var date = new Date(timestamp);
            var year = date.getFullYear();
            var month = date.getMonth() + 1;
            var day = date.getDate();
            var hours = date.getHours();
            var minutes = "0" + date.getMinutes();
            var seconds = "0" + date.getSeconds();
            // Will display time in xx/xx/xxxx 00:00:00 format
            return formattedTime = month + '/' + 
                                day + '/' + 
                                year + ' ' + 
                                hours + ':' + 
                                minutes.substr(-2) + 
                                ':' + seconds.substr(-2);
            }
};

Sabec

Answer 24

This one has a solution : which converts unixtime stamp to tim in js try this

var a = new Date(UNIX_timestamp*1000);
var hour = a.getUTCHours();
var min = a.getUTCMinutes();
var sec = a.getUTCSeconds();

Control

Answer 25

I learned a really cool way of converting a given Date object to a Unix timestamp from the source code of JQuery Cookie the other day.

Here's an example:

var date = new Date();
var timestamp = +date;

Discredit

I was about to write the new Date() Object .You can console log(new Date()) and then skim through the related methods under the new Date() object/ function – Andreeandrei

Answer 26

If want a basic way to generate a timestamp in Node.js this works well.

var time = process.hrtime();
var timestamp = Math.round( time[ 0 ] * 1e3 + time[ 1 ] / 1e6 );

Our team is using this to bust cache in a localhost environment. The output is /dist/css/global.css?v=245521377 where 245521377 is the timestamp generated by hrtime().

Hopefully this helps, the methods above can work as well but I found this to be the simplest approach for our needs in Node.js.

Vernacularize

Answer 27

For lodash and underscore users, use _.now.

var timestamp = _.now(); // in milliseconds

Syndicalism

Answer 28

As of writing this, the top answer is 9 years old, and a lot has changed since then - not least, we have near universal support for a non-hacky solution:

Date.now()

If you want to be absolutely certain that this won't break in some ancient (pre ie9) browser, you can put it behind a check, like so:

const currentTimestamp = (!Date.now ? +new Date() : Date.now());

This will return the milliseconds since epoch time, of course, not seconds.

MDN Documentation on Date.now

Paraplegia

Answer 29

Moment.js can abstract away a lot of the pain in dealing with Javascript Dates.

See: http://momentjs.com/docs/#/displaying/unix-timestamp/

moment().unix();

Valvate

Note that this gives the number of seconds (not milliseconds) since UNIX epoch. If you want the milliseconds, use moment().valueOf(). See my answer. – Boor

Answer 30

more simpler way:

var timeStamp=event.timestamp || new Date().getTime();

Ardolino

Do know where event comes from. You need to give a better explanation of the way you resolve it instead of you writing an answer. Please! – Struma

I was about to write the new Date() Object .You can console log(new Date()) and then skim through the related methods under the new Date() object/ function – Andreeandrei

Answer 31

sometime I need it in objects for xmlhttp calls, so I do like this.

timestamp : parseInt(new Date().getTime()/1000, 10)

Spokesman

Even shorter: new Date().getTime()/1000|0 but its slow and dirty – Chiseler

I was about to write the new Date() Object .You can console log(new Date()) and then skim through the related methods under the new Date() object/ function – Andreeandrei

Answer 32

Get TimeStamp In JavaScript

In JavaScript, a timestamp is the number of milliseconds that have passed since January 1, 1970.

If you don't intend to support < IE8, you can use

new Date().getTime(); + new Date(); and Date.now();

to directly get the timestamp without having to create a new Date object.

To return the required timestamp

new Date("11/01/2018").getTime()

Recency

Answer 33

//if you need 10 digits
   alert('timestamp '+ts());
function ts() {
    return parseInt(Date.now()/1000);

}

Grayce

Answer 34

var d = new Date();
console.log(d.valueOf()); 

Raisaraise

I was about to write the new Date() Object .You can console log(new Date()) and then skim through the related methods under the new Date() object/ function. the new Date().getTime() method will give you the time in the EPOCH format which can be interpreted if necessary – Andreeandrei

Answer 35

The advised, proper way is Number(new Date()), in terms of code- readability,

Also, UglifyJS and Google-Closure-Compiler will lower the complexity of the parsed code-logic-tree (relevant if you are using one of them to obscure/minify your code).

for Unix timestamp, which has a lower time resolution, just divide current number with 1000, keeping the whole.

Cookbook

Answer 36

I had to create a TIMESTAMP although the type on my DB mapping was String, for that I used

new Date().toISOString();

the output is like "2023-01-09T14:11:31.931Z"

Regen

Answer 37

var my_timestamp = ~~(Date.now()/1000);

Hakim

Answer 38

there are many ways to do it.

 Date.now() 
 new Date().getTime() 
 new Date().valueOf()

To get the timestamp in seconds, convert it using:

Math.floor(Date.now() / 1000)

Waft

Answer 39

Here is another solution to generate a timestamp in JavaScript - including a padding method for single numbers - using day, month, year, hour, minute and seconds in its result (working example at jsfiddle):

var pad = function(int) { return int < 10 ? 0 + int : int; };
var timestamp = new Date();

    timestamp.day = [
        pad(timestamp.getDate()),
        pad(timestamp.getMonth() + 1), // getMonth() returns 0 to 11.
        timestamp.getFullYear()
    ];

    timestamp.time = [
        pad(timestamp.getHours()),
        pad(timestamp.getMinutes()),
        pad(timestamp.getSeconds())
    ];

timestamp.now = parseInt(timestamp.day.join("") + timestamp.time.join(""));
alert(timestamp.now);

Dogtired

Answer 40

function getTimeStamp() {
    var now = new Date();
    return ((now.getMonth() + 1) + '/' +
            (now.getDate()) + '/' +
             now.getFullYear() + " " +
             now.getHours() + ':' +
             ((now.getMinutes() < 10)
                 ? ("0" + now.getMinutes())
                 : (now.getMinutes())) + ':' +
             ((now.getSeconds() < 10)
                 ? ("0" + now.getSeconds())
                 : (now.getSeconds())));
}

Dodie

Answer 41

To get time, month, day, year separately this will work

var currentTime = new Date();
var month = currentTime.getMonth() + 1;
var day = currentTime.getDate();
var year = currentTime.getFullYear();

Antimere

Answer 42

/**
 * Equivalent to PHP's time(), which returns
 * current Unix timestamp.
 *
 * @param  {string}  unit    - Unit of time to return.
 *                           - Use 's' for seconds and 'ms' for milliseconds.
 * @return {number}
 */
time(unit = 's') {
    return unit == 's' ? Math.floor(Date.now() / 1000) : Date.now()
}

Hyperphagia

Answer 43

With the upcoming Temporal API (stage 3), you can use the epoch* properties on Temporal.Instant.

For example, for the current timestamp in milliseconds you can use Temporal.Now

const instant = Temporal.Now.instant();
const timestamp = instant.epochMilliseconds;

Clipboard

Answer 44

time = Math.round(((new Date()).getTime()-Date.UTC(1970,0,1))/1000);

Cadell

@Skone technically nothing is screwed up. Date.UTC(1970,0,1) will always evaluate to 0, no matter what time zone the user is in. still, I'd say this is a bad answer because of it. – Savoury

@Savoury Good point. We're both getting at the same thing though, the additional arithmetic here is unnecessary. – Primogenial

If the Epoch changes, the definition of Unix Timestamp changes. That makes the above code backwards compatible, but broken :) – Wingover