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

+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 из 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 )

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

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

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

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

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

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

Теперь небольшое объяснение того, что делает |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/

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

В дополнение к другим параметрам, если вы хотите получить формат 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, нативный объект в JavaScript - это способ получения всех данных о времени.

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

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

Date.now(); //return 1495255666921

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

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

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

new Date().getTime();

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

Попробуйте пропустить прямой getTime() и использовать | 0 | 0 в качестве замены для функции Math.floor(). Также хорошо помнить, что 1E3 является более коротким эквивалентом для 1000 (заглавная буква E предпочтительнее, чем строчная, чтобы указать 1E3 в качестве константы).

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

var ts = new Date / 1E3 | 0;

console.log(ts);

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

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

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

(new Date).getTime() / 1000

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

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

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

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

Я настоятельно рекомендую использовать /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

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

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

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

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

Сегодня - 2018.06.27. Я приведу сравнение времени для чисто js-решений. Это может быть полезно для людей, которые хотят получить/измерить время в JS легким и эффективным способом (например, для приложений реального времени, таких как симуляции, игры и т.д.)

Протестировано на MacO High Sierra 10.13.3 на Chrome 67.0.3396.99 (64-разрядная версия), Safari 11.0.3 (13604.5.6), Firefox 59.0.2 (64-разрядная версия). На скриншоте ниже я показываю вам результаты для самого быстрого браузера (Safari):

Как я Date.now() был самым быстрым способом получения метки времени для всех трех браузеров. Safari выполняет 19,2 млн операций в секунду, Firefox 16,1 млн, Chrome 7,8 млн.

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

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

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

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

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

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

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

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

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

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

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

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

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 и underscore используйте _.now.

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

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

Вот пример:

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

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

Date.now()

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

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

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

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

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

Смотрите: http://momentjs.com/docs/#/displaying/unix-timestamp/

moment().unix();

более простой способ:

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

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

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

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

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

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

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

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

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

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

>> Return current timestamp

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

>> Return required timestamp

Вот еще одно решение для создания метки времени в 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);

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