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

+new Date

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

Date.now()

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

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

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

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

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

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

time();

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

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

Date.now() /1000 |0

предупреждение: это может перерыв в 2038 году и вернуть отрицательные числа, если вы делаете |0 магия. Использовать Math.floor() вместо этого к тому времени

Math.floor() устранение:

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

альтернативных всезнайка по Дерек 朕會功夫 взято из комментариев ниже этот ответ:

new Date/1e3|0

Polyfill, чтобы получить Date.now() работает:

чтобы заставить его работать в IE, вы можете сделать это (Polyfill from 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
    }
})();

некоторые результаты того, как это будет выглядеть:

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 )

конечно он сломает летнее время но в зависимости от чего вы строите это может быть полезно для вас, если вам нужно сделать binary операции на метки после int32 и будет перерыв в 2038.

это также вернет отрицательные значения, но только если пользователь этого ПК вы запускаете свой код, меняя часы своего ПК, по крайней мере, на 31 декабря прошлого года.

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

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

если вы используете jQuery, вы можете использовать $.now() как описано в документы jQuery что делает polyfill устаревшим с $.now() внутренне делает то же самое: (new Date).getTime()

если вы просто счастливы о версии jQuery рассмотреть upvoting этой ответ, так как я не нашел его сам.

теперь крошечное объяснение того, что |0 тут:

, предоставив |, вы говорите интерпретатору выполнить двоичную операцию или. Битовые операции требуют абсолютных чисел, которые превращают десятичный результат из Date.now() / 1000 в целое число.

во время этого преобразования десятичные дроби удаляются, что приводит к тому же результату, что и использование Math.floor() но, используя меньше кода.

будьте предупреждены, хотя: он преобразует 64-битный двойной в 32-битное целое число. Это приведет к потере информации при работе с огромным количеством. Метки времени сломаются после 2038 из-за переполнения 32-битного целого числа.

для получения дополнительной информации о Date.now перейдите по этой ссылке: Date.now() @ MDN

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

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

var timestamp = $.now();

^{(кроме того, он просто реализует (new Date).getTime() выражение)}

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

чтобы добавить, вот функция для возврата строки метки времени в 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;
}

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

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

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

Я еще не видел

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

еще один я еще не видел

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

на Date.getTime() метод можно использовать с небольшой настройкой:

значение, возвращаемое методом getTime, - это количество миллисекунд с 1 января 1970 00: 00: 00 UTC.

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

(new Date).getTime() / 1000

^{на Date.valueOf() метод функционально эквивалентно Date.getTime(), что позволяет использовать арифметические операторы на объект date для достижения идентичных результатов. На мой взгляд, такой подход влияет на читабельность.}

код Math.floor(new Date().getTime() / 1000) можно сократить до new Date / 1E3 | 0.

рассмотрим пропустить direct getTime() вызов и использовать | 0 в качестве замены Math.floor()

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

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

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

Date.now(); //return 1495255666921

В MDN упоминается как ниже:

Дата.метод now () возвращает количество миллисекунд, прошедших с момента 1 января 1970 00: 00: 00 UTC.
Поскольку now () является статическим методом даты, вы всегда используете его как дату.теперь.)(

Если вы используете версию ниже ES5,Date.now(); не работает и нужно использовать:

new Date().getTime();

вот простая функция для генерации метки времени в формате: 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())));
}

я настоятельно рекомендую использовать 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, см. Их docs

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

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

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

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

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

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

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

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

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

У этого есть решение : которое преобразует unixtime stamp в tim в js попробуйте это

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

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

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

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

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

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

вот пример:

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

на лодашь и подчеркивание пользователи, используйте _.now.

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

Это, кажется, работает.

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

момент.js может абстрагироваться от большой боли при работе с датами Javascript.

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

moment().unix();

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

Date.now()

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

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

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

документация по MDN Дата.теперь

более простым способом:

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

сегодня-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-бит). На скриншоте ниже я покажу вам результаты для fastest browser (Сафари):

как я наблюдаю Date.now() был быстрый способ получить метку времени для всех трех браузеров. Safari имеет 19.2 M операций в секунду, Firefox 16.1 M, Chrome 7.8 M.

на new Date()*1 был самым медленным для Chrome (2.8 M) и Firefox (2.6 M). The Number(new Date()) был самым медленным для Safari (2,9 м).

таким образом, код победителя js Date.now() и самый быстрый браузер-Safari (2x быстрее, чем chrome! ).

вы можете выполнить тест на компьютере здесь: https://jsperf.com/timestamp-test-x.

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

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