Короткие и яркие:

+ new Date()

Унарный оператор, такой как plus, запускает метод valueOf в объекте Date и возвращает метку времени (без каких-либо изменений).

Подробности:

Почти во всех текущих браузерах вы можете использовать Date.now() для получения метки времени UTC в миллисекунды; Заметным исключением из этого правила является IE8 и более ранние версии (см. таблица совместимости).

Однако вы можете легко сделать для этого прокладку:

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

Чтобы получить метку времени в секунды, вы можете использовать:

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

Или, в качестве альтернативы, вы можете использовать:

Date.now() / 1000 | 0

Что должно быть немного быстрее, но и менее читаемым (также увидеть этот ответ).

Я бы рекомендовал использовать Date.now() (с прокладкой совместимости). Это немного лучше, потому что оно короче и не создает новый объект Date. Однако, если вам не нужна прокладка и максимальная совместимость, вы можете использовать «старый» метод для получения отметки времени в миллисекунды:

new Date().getTime()

Что затем можно преобразовать в секунды следующим образом:

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

И вы также можете использовать метод valueOf, который мы показали выше:

new Date().valueOf()

Отметка времени в миллисекундах

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

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

Мне это нравится, потому что оно маленькое:

+new Date

Мне также это нравится, потому что он такой же короткий и совместим с современными браузерами, и более 500 человек проголосовали за него:

Date.now()

JavaScript работает с количеством миллисекунд, прошедших с эпохи, тогда как большинство других языков работают с секундами. Вы можете работать с миллисекундами, но как только вы передадите значение, чтобы сказать PHP, собственные функции PHP, вероятно, выйдут из строя. Поэтому, чтобы быть уверенным, я всегда использую секунды, а не миллисекунды.

Это даст вам отметку времени Unix (в секундах):

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

Это даст вам миллисекунды с эпохи (а не временную метку Unix):

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

Метод 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, если необходимо:

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

В этом ответе я предлагаю несколько решений с описаниями. Не стесняйтесь задавать вопросы, если что-то неясно
PS: к сожалению, кто-то слил это с верхним ответом, не придавая значения.

Быстрое и грязное решение:

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() решение:

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

Некоторая ботаная альтернатива Дерек 朕 會 功夫, взятая из комментариев под этим ответом:

new Date/1e3|0

Полифилл для работы Date.now():

Чтобы заставить его работать в IE, вы можете сделать это (Polyfill от MDN):

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

Если вас не волнует год / день недели / летнее время, вы можете убрать его и использовать после 2038 года:

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:

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.

Если вы просто хотите узнать относительное время с момента первого прогона кода, вы можете использовать что-то вроде этого:

var relativeTime = (function () {
    var start = Date.now();
    return function () {
        return Date.now() - start
    }
})();

Если вы используете jQuery, вы можете использовать $.now(), как описано в Документы jQuery, что делает полифил устаревшим, поскольку $.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

Чтобы подвести итог, вот функция, возвращающая строку отметки времени в Javascript. Пример: 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;
}

jQuery предоставляет свой собственный метод для получения отметки времени:

var timestamp = $.now();

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

ССЫЛКА:http://api.jquery.com/jQuery.now/

Любые браузеры, не поддерживающие Date.now, вы можете использовать это для получения текущей даты и времени:

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

Вот простая функция для создания отметки времени в формате: мм / дд / гг чч: ми: сс

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

У этого есть решение: который преобразует временную метку unix во время в js, попробуйте это

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

иногда мне это нужно в объектах для вызовов xmlhttp, поэтому мне это нравится.

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

Вот еще одно решение для создания метки времени в JavaScript, включая метод заполнения для отдельных чисел, с использованием дня, месяца, года, часа, минуты и секунд в его результате (рабочий пример на 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);

Moment.js может избавить вас от многих проблем, связанных с датами Javascript.

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

moment().unix();

На днях я узнал действительно классный способ преобразования заданного объекта Date в метку времени Unix из исходного кода JQuery Cookie.

Вот пример:

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

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

Рекомендуемый, правильный способ - Number(new Date()), с точки зрения читабельности кода,

Кроме того, UglifyJS и Google-Closure-Compiler снизят сложность анализируемого дерева логики кода (актуально, если вы используете одно из них, чтобы скрыть / минимизировать свой код).

для временной метки Unix, которая имеет более низкое временное разрешение, просто разделите текущее число на 1000, сохранив целое.

Для пользователей Lodash и нижнее подчеркивание используйте _.now.

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

Если вам нужен базовый способ создания метки времени в Node.js, это хорошо работает.

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

Наша команда использует это для очистки кеша в среде localhost. На выходе получается /dist/css/global.css?v=245521377, где 245521377 - метка времени, созданная hrtime().

Надеюсь, это поможет, приведенные выше методы также могут работать, но я обнаружил, что это самый простой подход для наших нужд в Node.js.

Для метки времени с разрешением в микросекунды есть performance.now:

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

Это может, например, дать 1436140826653.139, тогда как Date.now дает только 1436140826653.

Я настоятельно рекомендую использовать moment.js. Чтобы получить количество миллисекунд с эпохи UNIX, выполните

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, см. Их документы

Кажется, это работает.

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

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

console.info(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() и использовать | 0 в качестве замены функции Math.floor(). Также хорошо помнить, что 1E3 является более коротким эквивалентом 1000 (верхний регистр E предпочтительнее, чем нижний регистр, чтобы указать 1E3 как константу).

В результате вы получите следующее:

var ts = new Date / 1E3 | 0;

console.info(ts);

В дополнение к другим параметрам, если вам нужен ISO-формат даты, вы можете получить его напрямую

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

Вы можете использовать только

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

чтобы получить текущую отметку времени. Не нужно делать ничего лишнего.

Датировать, родной объект в JavaScript - это способ получения всех данных о времени.

Просто будьте осторожны в JavaScript, отметка времени зависит от установленного клиентского компьютера, поэтому она не является точной на 100%. Чтобы получить лучший результат, вам нужно получить метку времени из на стороне сервера.

В любом случае, я предпочитаю использовать ваниль. Это обычный способ сделать это в JavaScript:

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(); не работает, и вам необходимо использовать:

new Date().getTime();

На момент написания этого главного ответа было 9 лет, и с тех пор многое изменилось - не в последнюю очередь, у нас есть почти универсальная поддержка не-хакерского решения:

Date.now()

Если вы хотите быть абсолютно уверены, что это не сломается в каком-нибудь древнем (до IE9) браузере, вы можете проверить это, например:

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

Это вернет миллисекунды с момента времени, конечно, не секунды.

Документация MDN на Date.now

Представление

Сегодня - 23.04.2020 провожу тестирование выбранных решений. Я тестировал MacOs High Sierra 10.13.6 в Chrome 81.0, Safari 13.1, Firefox 75.0

Выводы

• Решение Date.now() (E) является самым быстрым в Chrome и Safari и вторым по скорости в Firefox, и это, вероятно, лучший выбор для быстрого кросс-браузерного решения.
• Решение performance.now() (G), что удивительно, более чем в 100 раз быстрее других решений в Firefox, но самое медленное в Chrome.
• Решения C, D, F довольно медленные во всех браузерах.

Подробности

Результаты для хром

Вы можете выполнить тест на своей машине ЗДЕСЬ

Код, используемый в тестах, представлен во фрагменте ниже.

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.info(`${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"

Получить отметку времени в 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();

чтобы напрямую получить метку времени, не создавая новый объект Date.

To return the required timestamp

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

есть много способов сделать это.

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

To get the timestamp in seconds, convert it using:

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