date:你如何获得JavaScript的时间戳？


How do you get a timestamp in JavaScript?

如何在JavaScript中获得时间戳?

类似于Unix的时间戳，即表示当前时间和日期的单个数字。可以是数字，也可以是字符串。

相关讨论

短,时髦的:

1
+ new Date()

像plus这样的一元运算符触发Date对象中的valueOf方法，并返回时间戳(没有任何更改)。

细节:

在几乎所有当前浏览器上，都可以使用Date.now()以毫秒为单位获取UTC时间戳;一个值得注意的例外是IE8和更早版本(参见兼容性表)。

不过，你可以很容易地做一个垫片:

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

要获得以秒为单位的时间戳，可以使用:

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

或者你也可以用:

1
Date.now() / 1000 | 0

这应该会稍微快一点，但也不太容易读(也请参阅这个答案)。

我建议使用Date.now()(兼容垫片)。稍微好一点，因为它比较短。不创建新的Date对象。然而，如果你不想要垫片，最大兼容性，你可以使用"老"方法得到时间戳(毫秒):

1
new Date().getTime()

然后你可以像这样把它转换成秒:

1
Math.round(new Date().getTime()/1000)

你也可以使用我们上面展示的valueOf方法:

1
new Date().valueOf()

时间戳以毫秒为单位

1
2
3
var timeStampInMs = window.performance && window.performance.now && window.performance.timing && window.performance.timing.navigationStart ? window.performance.now() + window.performance.timing.navigationStart : Date.now();

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

相关讨论

我喜欢这个，因为它很小:

1
+new Date

我也喜欢这个，因为它和现代浏览器一样短，而且兼容，超过500人投票认为它更好:

1
Date.now()
相关讨论

JavaScript使用从纪元开始的毫秒数，而大多数其他语言使用秒数。您可以使用毫秒，但只要传递一个值给PHP, PHP本机函数可能就会失败。所以我总是用秒，而不是毫秒。

这将给您一个Unix时间戳(以秒为单位):

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

这将给你毫秒自历元(不是Unix时间戳):

1
var milliseconds = new Date().getTime();
相关讨论

1
2
3
4
5
var time = Date.now || function() {
  return +new Date;
};

time();
相关讨论

我在这个答案中提供了多个解决方案，并进行了描述。如果有什么不清楚的地方，尽管提出来PS:遗憾的是，有人把这句话合并到了最上面的答案中，却没有给出答案的出处。

快速和肮脏的解决方案:

1
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()的解决方案:

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

一些书呆子替代德里克。朕會功夫从评论下面的回答:

1
new Date/1e3|0

Polyfill使Date.now()工作:

要让它在IE中工作，你可以这样做(Polyfill来自MDN):

1
2
3
4
5
if (!Date.now) {
    Date.now = function now() {
        return new Date().getTime();
    };
}

如果你不关心年/日/周/夏令时，你可以把它拿掉，2038年后再用:

1
2
3
4
5
6
var now = (function () {
    var year = new Date(new Date().getFullYear().toString()).getTime();
    return function () {
        return Date.now() - year
    }
})();

Some output of how it will look:

1
2
3
4
new Date()
Thu Oct 29 2015 08:46:30 GMT+0100 (Mitteleurop?ische Zeit )
new Date(now())
Thu Oct 29 1970 09:46:30 GMT+0100 (Mitteleurop?ische Zeit )

Of course it will break daylight saving time but depending on what you
are building this might be useful to you if you need to do binary
operations on timestamps after int32 will break in 2038.

This will also return negative values but only if the user of that PC
you are running your code on is changing their PC's clock at least to
31th of december of the previous year.

如果你只是想知道从代码第一次运行到现在的相对时间，你可以这样做:

1
2
3
4
5
6
var relativeTime = (function () {
    var start = Date.now();
    return function () {
        return Date.now() - start
    }
})();

如果您正在使用jQuery，您可以使用jQuery文档中描述的$.now()，这将使polyfill过时，因为$.now()在内部做同样的事情:(new Date).getTime()

如果您对jQuery的版本很满意，请考虑投票支持这个答案，因为我自己也没有找到它。

现在简单解释一下|0的作用:

通过提供|，您可以告诉解释器执行二进制或操作。位操作需要绝对值，它将Date.now() / 1000的小数结果转换为整数。

在转换期间，小数被删除，结果与使用Math.floor()相同，但是使用的代码更少。

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.

有关Date.now的进一步信息，请遵循以下链接:Date.now() @ MDN

相关讨论

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

jQuery提供了自己的方法来获取时间戳:

1
var timestamp = $.now();

(此外它只是实现了(new Date).getTime()表达式)

裁判:http://api.jquery.com/jQuery.now/

相关讨论

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

相关讨论

加起来，这里有一个函数在Javascript中返回一个时间戳字符串。例如:15:06:38点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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;
}
相关讨论

除了其他选项，如果您想要一个dateformat ISO，您可以直接获得它

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

相关讨论

Date, JavaScript中的原生对象是我们获取所有关于时间的数据的方式。

在JavaScript中要注意时间戳依赖于客户机计算机集，所以它不是100%准确的时间戳。要获得最佳结果，您需要从服务器端获取时间戳。

总之，我更喜欢香草。这是在JavaScript中常用的方法:

1
Date.now(); //return 1495255666921

在MDN中，具体如下:

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().

如果你使用的版本低于ES5， Date.now();不工作，你需要使用:

1
new Date().getTime();

一个我还没见过的

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

另一个我还没见过的是

1
2
var _ = require('lodash'); // from here https://lodash.com/docs#now
_.now();
相关讨论

Date.getTime()方法可以稍微调整一下:

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

将结果除以1000得到Unix时间戳，如有必要，floor:

1
(new Date).getTime() / 1000

Date.valueOf()方法在功能上等同于Date.getTime()，这使得在date对象上使用算术运算符可以得到相同的结果。在我看来，这种方法影响可读性。

相关讨论

代码Math.floor(new Date().getTime() / 1000)可以缩短为new Date / 1E3 | 0。

考虑跳过直接的getTime()调用，使用| 0替换Math.floor()函数。还需要记住1E3是1000的更短的等价词(大写E比小写E更适合表示1E3是常量)。

因此，您得到以下信息:

1
2
3
var ts = new Date / 1E3 | 0;

console.log(ts);

相关讨论

我强烈推荐使用moment.js。要获得自UNIX纪元以来的毫秒数，请执行以下操作

1
moment().valueOf()

要获得自UNIX纪元以来的秒数，请执行以下操作

1
moment().unix()

你也可以这样转换时间:

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

我经常这样做。没有双关。

要在浏览器中使用moment.js:

1
2
3
4
<script src="moment.js"></script>
<script>
    moment().valueOf();
</script>

有关更多细节，包括安装和使用MomentJS的其他方法，请参阅他们的文档

下面是一个生成时间戳的简单函数，格式为:mm/dd/yy hh:mi:ss

1
2
3
4
5
6
7
8
9
10
11
12
13
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())));
}
相关讨论

你只能用

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

获取当前时间戳。不需要做任何额外的事情。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 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
1
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

对于微秒分辨率的时间戳，有performance.now:

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

例如，这可以生成1436140826653.139，而Date.now只生成1436140826653。

任何浏览器不支持日期。现在，你可以用这个获取当前日期时间:

1
currentTime = Date.now() || +new Date()
相关讨论

今天- 2018.06.27我提供了一些纯js解决方案的时间对比。这对于那些想用JS轻松/高效地获取/测量时间的人来说是很有用的。实时应用，如模拟，游戏等)

在MacOs High Sierra 10.13.3的Chrome 67.0.3396.99(64位)、Safari 11.0.3(13604.5.6)和Firefox 59.0.2(64位)上测试。在下面的截图中，我向你展示了最快的浏览器(Safari)的结果:

enter image description here

据我观察，Date.now()是获得所有三种浏览器的时间戳的最快方法。Safari每秒运行1920万次，Firefox每秒运行1610万次，Chrome每秒运行780万次。

对于Chrome (2.8M)和Firefox (2.6M)来说，new Date()*1是最慢的。对于Safari来说，Number(new Date())是最慢的(2.9M)。

所以胜出的JS代码是Date.now()，最快的浏览器是Safari(比chrome快两倍!)

您可以在这里的机器上执行测试:https://jsperf.com/timestamp-test-x。

这个有一个解决方案:在js中将unixtime戳记转换为tim

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

如果需要在Node.js中生成时间戳的基本方法，可以使用这个方法。

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

我们的团队正在使用它来破坏本地主机环境中的缓存。输出是/dist/css/global.css?v=245521377，其中245521377是由hrtime()生成的时间戳。

希望这能有所帮助，上面的方法也可以工作，但是我发现这是Node.js中最简单的方法。

前几天，我从JQuery Cookie的源代码中学到了一种非常酷的方法，可以将给定的日期对象转换为Unix时间戳。

这里有一个例子:

1
2
var date = new Date();
var timestamp = +date;
相关讨论

这似乎行得通。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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);
            }
};
相关讨论

对于lodash和下划线用户，使用_.now。

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

js可以抽象出处理Javascript日期时的许多痛苦。

参见:http://momentjs.com/docs/ /显示/ unix时间戳

1
moment().unix();
相关讨论

写这篇文章的时候，最热门的答案是9年前的，自那以后发生了很多变化——尤其是，我们几乎普遍支持非hacky解决方案:

1
Date.now()

如果你想绝对肯定这不会在一些古老的(ie9之前的)浏览器中崩溃，你可以把它放在一个复选框后面，就像这样:

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

当然，这将返回自历元时间以来的毫秒，而不是秒。

MDN文档，现在

更简单的方法:

1
var timeStamp=event.timestamp || new Date().getTime();
相关讨论

有时，我需要它在对象中用于xmlhttp调用，所以我喜欢这样做。

1
timestamp : parseInt(new Date().getTime()/1000, 10)
相关讨论

建议正确的方法是Number(new Date())，在代码可读性方面，

此外，UglifyJS和google - close - compiler将降低解析后的代码逻辑树的复杂性(如果您使用它们中的一个来隐藏/缩小您的代码，这是相关的)。

对于时间分辨率较低的Unix时间戳，只需用1000除当前编号，保留整个值。

1
2
var d = new Date();
console.log(d.valueOf());
相关讨论

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

相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
13
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())));
}

下面是用JavaScript生成时间戳的另一个解决方案——包括填充单个数字的方法——在结果中使用日、月、年、小时、分钟和秒(jsfiddle上的工作示例):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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);
1
2
3
4
5
6
7
new Date().getTime(); and Date.now();

>> Return current timestamp

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

>> Return required timestamp
相关讨论

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