时间戳（以毫秒为单位）

要获取自 Unix 纪元以来的毫秒数，请调用 Date.now：

Date.now()

或者，使用一元运算符调用 Date.prototype.valueOf：+

+ new Date()

或者，直接调用 valueOf：

new Date().valueOf()

若要支持 IE8 及更早版本（请参阅兼容性表），请为以下项创建填充码：Date.now

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

或者，直接调用 getTime：

new Date().getTime()

时间戳（以秒为单位）

要获取自 Unix 纪元以来的秒数，即 Unix 时间戳：

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

或者，使用按位或到地板速度稍快，但可读性也较差，并且将来可能会中断（参见解释 1、2）：

Date.now() / 1000 | 0

以毫秒为单位的时间戳（更高分辨率）

使用 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());

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

time();

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

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

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

+new Date

我也喜欢这个，因为它同样短，并且与现代浏览器兼容，并且有超过 500 人投票认为它更好：

Date.now()

JavaScript 使用自纪元以来的毫秒数，而大多数其他语言使用秒数。你可以用毫秒来工作，但一旦你传递一个值来表示 PHP，PHP 本机函数可能会失败。因此，为了确保我总是使用秒，而不是毫秒。

这将为您提供一个 Unix 时间戳（以秒为单位）：

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

这将为您提供自纪元以来的毫秒数（不是 Unix 时间戳）：

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

Date.getTime（） 方法只需稍作调整即可使用：

getTime 方法返回的值是毫秒数 自 1970 年 1 月 1 日 00：00：00 UTC 起。

将结果除以 1000 以获得 Unix 时间戳，如有必要，请下限：

(new Date).getTime() / 1000

^{Date.valueOf（） 方法在功能上等同于 Date.getTime（），这使得对日期对象使用算术运算符来实现相同的结果成为可能。在我看来，这种方法会影响可读性。}

我在此答案中提供了多种解决方案和描述。如果有任何不清楚的地方，请随时提出问题

快速而肮脏的解决方案：

Date.now() /1000 |0

警告：它可能会在 2038 年中断，如果您执行 |0 魔术，它可能会返回负数。届时请改用 Math.floor（）

Math.floor（） 解决方案：

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

Derek 朕會功夫的一些书替代品取自此答案下方的评论：

new Date/1e3|0

Polyfill 让 Date.now（） 工作：

要让它在 IE 中工作，您可以这样做（来自 MDN 的 Polyfill）：

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

如果您不关心年份/星期几/夏令时，您需要记住 2038 年之后的日期：

按位运算将导致使用 32 位整数而不是 64 位浮点。

您需要将其正确用作：

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

如果你只想知道从代码第一次运行开始的相对时间，你可以使用这样的东西：

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

如果您使用的是 jQuery，则可以使用 jQuery 文档中描述的 $.now（），这使得 polyfill 过时，因为 $.now（） 在内部执行相同的操作：（new Date）.getTime（）

如果您只是对jQuery的版本感到满意，请考虑对这个答案投赞成票，因为我自己没有找到它。

现在对 |0 的作用进行一个小小的解释：

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

在该转换过程中，将删除小数点，从而产生与 using 输出的结果类似的结果。Math.floor()

但请注意：它会将 64 位双精度转换为 32 位整数。
这将导致在处理大量数据时丢失信息。
由于 32 位整数溢出，时间戳将在 2038 年后中断，除非 Javascript 在严格模式下移动到 64 位整数。

有关 Date.now 的更多信息，请访问以下链接：Date.now（） @ MDN

总而言之，这里有一个在 Javascript 中返回时间戳字符串的函数。 示例：下午 15：06：38

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;
}

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

var timestamp = $.now();

^{（此外，它只是实现了（new Date）.getTime（）表达式）}

编号： http://api.jquery.com/jQuery.now/

任何不支持的浏览器 Date.now，您可以使用它来获取当前日期时间：

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

下面是一个简单的函数，用于生成格式为：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())));
}

这个有一个解决方案：在js中将unixtimestamp转换为tim 试试这个

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

更简单的方法：

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

我还没见过

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

另一个我还没见过的是

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

Moment.js可以抽象出处理Javascript Dates的很多痛苦。

请参见：http://momentjs.com/docs/#/displaying/unix-timestamp/

moment().unix();

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

下面是一个示例：

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

对于 lodash 和 underscore 用户，请使用 ._.now

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

如果想要一种在 Node.js 中生成时间戳的基本方法，这很有效。

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

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

希望这会有所帮助，上面的方法也可以工作，但我发现这是满足我们在 Node.js 中需求的最简单方法。

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

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

例如，这可以产生 ，而只给出 .1436140826653.139Date.now1436140826653

我强烈建议使用 .要获取自 UNIX 纪元以来的毫秒数，请执行moment.js

moment().valueOf()

要获取自 UNIX 纪元以来的秒数，请执行

moment().unix()

您也可以像这样转换时间：

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

我一直都是这样做的。没有双关语的意思。

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

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

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

// 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>

这似乎有效。

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);
            }
};

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

考虑跳过直接 getTime（） 调用并用作 Math.floor（） 函数的替代品。 同样值得记住的是，它是一个较短的等价物（大写字母 E 比小写字母更受欢迎，以指示为常量）。| 01E310001E3

因此，您将得到以下内容：

var ts = new Date / 1E3 | 0;

console.log(ts);

除了其他选项之外，如果你想要一个日期格式的ISO，你可以直接得到它

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

您只能使用

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

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

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

请注意，在 JavaScript 中，时间戳取决于客户端计算机设置，因此它不是 100% 准确的时间戳。为了获得最佳结果，您需要从服务器端获取时间戳。

无论如何，我的首选方法是使用香草。这是在 JavaScript 中执行此操作的常见方法：

Date.now(); //return 1495255666921

在 MDN 中，它提到如下：

Date.now（） 方法返回自那以后经过的毫秒数 1970 年 1 月 1 日 00：00：00 UTC。
因为 now（） 是 Date 的静态方法，所以你总是把它当作 Date.now（） 来使用。

如果您使用的版本低于 ES5，则不起作用，您需要使用：Date.now();

new Date().getTime();

在撰写本文时，最重要的答案是 9 年前，从那时起发生了很多变化——尤其是，我们对非黑客解决方案的几乎普遍支持：

Date.now()

如果你想绝对确定这不会在一些古老的（ie9 之前）浏览器中中断，你可以把它放在一个检查后面，如下所示：

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

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

Date.now 上的 MDN 文档

性能

今天 - 2020.04.23 我对选定的解决方案进行测试。我在 Chrome 81.0、Safari 13.1、Firefox 75.0 上的 MacOs High Sierra 10.13.6 上进行了测试

结论

• 解决方案（E）在Chrome和Safari上速度最快，在Firefox上速度第二快，这可能是快速跨浏览器解决方案的最佳选择Date.now()
• 令人惊讶的是，解决方案（G）比Firefox上的其他解决方案快100倍以上，但在Chrome上却最慢performance.now()
• 解决方案 C、D、F 在所有浏览器上都非常慢

详

chrome 的搜索结果

您可以在您的机器上执行测试 这里

测试中使用的代码如下图所示

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

如果用于日志记录，则可以使用 ISOString

new Date().toISOString()

“2019-05-18T20：02：36.694Z”