Podoba mi się to, bo jest małe:

+new Date

Podoba mi się również to, ponieważ jest tak samo krótki i jest kompatybilny z nowoczesnymi przeglądarkami, a ponad 500 osób głosowało, że jest lepszy: {]}

Date.now()

JavaScript pracuje z liczbą milisekund od epoki, podczas gdy większość innych języków pracuje z sekundami. Możesz pracować z milisekundami, ale jak tylko przekażesz wartość PHP, natywne funkcje PHP prawdopodobnie zawiodą. Więc dla pewności zawsze używam sekund, a nie milisekund.

To da Ci uniksowy znacznik czasu (w sekundach):

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

To da ci milisekundy od epoki (Nie Unix timestamp):

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

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

time();

podaję wiele rozwiązań z opisami w tej odpowiedzi. Możesz zadawać pytania, jeśli coś jest niejasne
PS: niestety ktoś włączył to do topowej odpowiedzi nie dając kredytu.

Szybkie i brudne rozwiązanie:

Date.now() /1000 |0

Ostrzeżenie: toMoże złamać się w 2038 roku i zwrócić liczby ujemne, jeśli wykonasz magię |0. Użyj Math.floor() zamiast tego do tego czasu

Math.floor() rozwiązanie:

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

Niektóre nerdy alternatywa przez Derek 朕會功夫 wzięte z komentarzy poniżej tej odpowiedzi:

new Date/1e3|0

Polyfill to get Date.now() działa:

Aby to działało w IE możesz to zrobić (Polyfill z MDN):

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

Jeśli nie dbasz o rok / Dzień tygodnia / czas letni, możesz go rozebrać i użyć tego po 2038:

var now = (function () {
    var year = new Date(new Date().getFullYear().toString()).getTime();
    return function () {
        return Date.now() - year
    }
})();

Jak to będzie wyglądało:

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 )

Oczywiście, że przerwie czas letni, ale w zależności od tego, co są budowanie to może być przydatne dla Ciebie, jeśli trzeba zrobić binary operacje na znacznikach czasu po int32 zostaną przerwane w 2038 roku.

Zwróci to również wartości ujemne, ale tylko wtedy, gdy użytkownik tego komputera uruchamiasz swój kod zmienia zegar komputera przynajmniej na 31 grudnia poprzedniego roku.

Jeśli po prostu chcę znać względny czas od momentu, kiedy Kod został uruchomiony pierwszy można użyć czegoś takiego:

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

Jeśli używasz jQuery, możesz użyć $.now(), jak opisano w jQuery ' s Docs, co sprawia, że polyfill jest przestarzały, ponieważ $.now() wewnętrznie robi to samo: (new Date).getTime()

Jeśli jesteś zadowolony z wersji jQuery rozważ upvoting to odpowiedź ponieważ nie znalazłem siebie.

Teraz małe wyjaśnienie tego, co |0 robi:

Podając |, nakazujesz interpreterowi wykonanie operacji binarnej lub operacji. Operacje bitowe wymagają liczb bezwzględnych, które zmieniają wynik dziesiętny z Date.now() / 1000 W liczbę całkowitą.

Podczas tej konwersji, liczby dziesiętne są usuwane, co daje taki sam wynik jak przy użyciu Math.floor(), ale przy użyciu mniejszego kodu.

Pamiętaj jednak: konwertuje 64-bitowy Podwójny na 32-bitowy liczba całkowita. Spowoduje to utratę informacji podczas radzenia sobie z ogromnymi liczbami. Znaczniki czasu ulegną awarii po 2038 roku z powodu 32-bitowego przepełnienia liczby całkowitej.

Aby uzyskać więcej informacji na temat Date.now kliknij ten link: Date.now() @ MDN

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

jQuery dostarcza własną metodę, aby uzyskać znacznik czasu:

var timestamp = $.now();

^{(poza tym implementuje (new Date).getTime() wyrażenie)}

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

Aby dodać, oto funkcja zwracająca łańcuch znacznika czasu w Javascript. Przykład: 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;
}

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

Oprócz innych opcji, jeśli chcesz dateformat ISO, możesz uzyskać go bezpośrednio

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

One I haven ' t seen yet

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

Kolejny, którego jeszcze nie widziałem to

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

The Date.getTime() metoda może być używana z małym tweak:

Wartością zwracaną przez metodę getTime jest liczba milisekund od 1 stycznia 1970 00: 00: 00 UTC.

Podziel wynik przez 1000, aby uzyskać znacznik czasu Uniksa, floor w razie potrzeby:

(new Date).getTime() / 1000

^{Metoda Date.valueOf() jest funkcjonalnie równoważna Date.getTime(), co umożliwia wykorzystanie operatorów arytmetycznych na obiekcie date w celu uzyskania identycznych wyników. Moim zdaniem to podejście wpływa na czytelność.}

Kod {[1] } można skrócić do new Date / 1E3 | 0.

Rozważmy pominięcie bezpośredniego getTime() wywołanie i użycie | 0 jako zamiennika dla Math.floor() funkcja. Warto również pamiętać, że {[6] } jest krótszym odpowiednikiem 1000 (duże litery E są preferowane do wskazania 1E3 jako stałej).

W rezultacie otrzymujesz:

var ts = new Date / 1E3 | 0;

console.log(ts);

Date natywny obiekt w JavaScript jest sposobem, w jaki otrzymujemy wszystkie dane o czasie.

Po prostu uważaj w JavaScript znacznik czasu zależy od ustawienia komputera klienta, więc nie jest to 100% dokładny znacznik czasu. Aby uzyskać najlepszy wynik, musisz pobrać znacznik czasu z Po stronie serwera .

Date.now(); //return 1495255666921

W MDN jest wymienione jak poniżej:

The Data.metoda now () Zwraca liczbę milisekund, które upłynęły od 1 stycznia 1970 00: 00: 00 UTC.
Ponieważ now() jest statyczną metodą Date, zawsze używasz jej jako Date.teraz().

Jeśli używasz wersji poniżej ES5, Date.now(); nie działa i musisz użyć:

new Date().getTime();

Oto prosta funkcja do generowania znacznika czasu w formacie: 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())));
}

Gorąco polecam stosowanie moment.js. Aby uzyskać liczbę milisekund od epoki Uniksa, wykonaj

moment().valueOf()

Aby uzyskać liczbę sekund od epoki Uniksa, wykonaj

moment().unix()

Możesz również konwertować czasy w następujący sposób:

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

Aby użyć moment.js w przeglądarce:

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

Aby uzyskać więcej informacji, w tym inne sposoby instalacji i korzystania z MomentJS, zobacz ich 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>

Możesz używać tylko

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

Aby pobrać bieżący znacznik czasu. Nie musisz robić nic więcej.

Dla znacznika czasu z rozdzielczością mikrosekund, jest performance.now:

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

Może to na przykład dać 1436140826653.139, podczas gdy Date.now daje tylko 1436140826653.

Wszelkie przeglądarki nieobsługiwane daty.teraz możesz użyć tego do uzyskania aktualnej daty Czas:

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

Ten ma rozwiązanie: które konwertuje znacznik unixtime na tim w js try this

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

Jeśli chcesz uzyskać podstawowy sposób generowania znacznika czasu w węźle.js to działa dobrze.

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

Nasz zespół używa tego do rozbicia pamięci podręcznej w środowisku localhost. Wyjście to /dist/css/global.css?v=245521377, Gdzie {[2] } jest znacznikiem czasu wygenerowanym przez hrtime().

Mam nadzieję, że to pomoże, powyższe metody również mogą działać, ale okazało się, że jest to najprostsze podejście do naszych potrzeb w Node.js.

Niedawno nauczyłem się naprawdę fajnego sposobu konwersji danego obiektu daty na znacznik czasu Uniksa z kodu źródłowego jQuery Cookie.

Oto przykład:

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

Dla lodash i podkreślają użytkownicy, użyj _.now.

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

To chyba działa.

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

Chwila.js może usunąć wiele bólu w radzeniu sobie z datami Javascript.

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

moment().unix();

W momencie pisania tego, najlepsza odpowiedź ma 9 lat i wiele się zmieniło od tego czasu - nie mniej, mamy prawie uniwersalne wsparcie dla rozwiązania nie-hacky:

Date.now()

Jeśli chcesz być absolutnie pewien, że nie złamie się to w jakiejś starożytnej (pre ie9) przeglądarce, możesz umieścić go za czekiem, w ten sposób:

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

Zwróci to oczywiście milisekundy od czasu epoki, Nie sekundy.

Dokumentacja MDN na bieżąco.teraz

Prostszy sposób:

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

Dzisiaj-2018.06.27 podaję porównanie czasu dla czystych rozwiązań js. Może to być przydatne dla osób, które chcą uzyskać / zmierzyć czas w JS w sposób lekki / wydajny (np. do zastosowań w czasie rzeczywistym, takich jak symulacje, gry itp.)

Przetestowano na MacOs High Sierra 10.13.3 na Chrome 67.0.3396.99( 64-bit), Safari 11.0.3( 13604.5.6), Firefox 59.0.2 (64-bit). Na poniższym zrzucie ekranu pokazuję wyniki dla najszybszej przeglądarki (Safari):

Jak obserwuję Date.now() było najszybsza metoda uzyskania znacznika czasu dla wszystkich trzech przeglądarek. Safari ma 19,2 mln operacji na sekundę, Firefox 16,1 mln, Chrome 7,8 mln.]}

new Date()*1 był najwolniejszy dla Chrome (2,8 M) i Firefox (2,6 m). [[2]] był najwolniejszy jak na Safari (2,9 M).

Tak więc zwycięzcą kodu JS jest Date.now(), a najszybszą przeglądarką jest Safari (2x szybsza niż chrome! ).

Możesz wykonać test na swojej maszynie tutaj: https://jsperf.com/timestamp-test-x .

Czasami potrzebuję go w obiektach dla wywołań xmlhttp, więc lubię to.

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