Jak mogę uzyskać znacznik czasu w JavaScript?

Coś podobnego do uniksowego znacznika czasu , to znaczy pojedyncza liczba reprezentująca bieżącą godzinę i datę. Albo jako liczba, albo jako ciąg.

Krótkie i snazzy:

+ new Date()

Jednoargumentowy operator pluswyzwala valueOfmetodę w Dateobiekcie i zwraca znacznik czasu (bez żadnych zmian).

Detale:

W prawie wszystkich aktualnych przeglądarkach możesz użyć, Date.now()aby uzyskać znacznik czasu UTC w milisekundach ; godnym uwagi wyjątkiem jest IE8 i wcześniejsze (patrz tabela kompatybilności ).

Możesz łatwo to zrobić, ale:

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

Aby uzyskać znacznik czasu w kilka sekund , możesz użyć:

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

Lub alternatywnie możesz użyć:

Date.now() / 1000 | 0

Co powinno być nieco szybsze, ale także mniej czytelne ( zobacz także tę odpowiedź ).

Polecam używanie Date.now()(z podkładką kompatybilności). Jest nieco lepszy, ponieważ jest krótszy i nie tworzy nowego Dateobiektu. Jeśli jednak nie chcesz mieć ogranicznika i maksymalnej kompatybilności, możesz użyć „starej” metody, aby uzyskać znacznik czasu w milisekundach :

new Date().getTime()

Które możesz następnie przekonwertować na sekundy:

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

Możesz także użyć valueOfmetody, którą pokazaliśmy powyżej:

new Date().valueOf()

Znacznik czasu w milisekundach

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

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

Podoba mi się to, ponieważ jest małe:

+new Date

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

Date.now()

JavaScript działa z liczbą milisekund od epoki, podczas gdy większość innych języków działa z sekundami. Możesz pracować z milisekundami, ale jak tylko przekażesz wartość mówiącą o 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 uniksowy znacznik czasu):

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

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

time();

Podaję wiele rozwiązań z opisami w tej odpowiedzi. Nie krępuj się zadawać pytań, jeśli coś jest niejasne
PS: niestety ktoś połączył to z najwyższą odpowiedzią bez uznania.

Szybkie i brudne rozwiązanie:

Date.now() /1000 |0

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

Math.floor() rozwiązanie:

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

Jakaś nerdowa alternatywa Dereka 朕 會 功夫 zaczerpnięta z komentarzy pod tą odpowiedzią:

new Date/1e3|0

Polyfill, aby zacząć Date.now()działać:

Aby uruchomić go w IE, możesz to zrobić (Polyfill z MDN ):

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

Jeśli nie obchodzi Cię rok / dzień tygodnia / czas letni, możesz go rozebrać i użyć po 2038 r .:

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

Niektóre dane wyjściowe tego, jak to będzie wyglądać:

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, to zepsuje czas letni, ale w zależności od tego, co budujesz, może to być przydatne, jeśli musisz wykonywać operacje binarne na znacznikach czasu po tym, jak int32 ulegnie awarii w 2038 roku.

To również zwróci wartości ujemne, ale tylko jeśli użytkownik tego komputera, na którym uruchomisz kod, zmieni zegar swojego komputera co najmniej do 31 grudnia poprzedniego roku.

Jeśli chcesz znać czas względny od momentu uruchomienia kodu, możesz 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()zgodnie z opisem w Dokumentach jQuery, co sprawia, że ​​wypełnianie jest przestarzałe, ponieważ $.now()wewnętrznie robi to samo:(new Date).getTime()

Jeśli jesteś zadowolony z wersji jQuery, zastanów się nad poprawieniem tej odpowiedzi, ponieważ sam jej nie znalazłem.

Teraz małe wyjaśnienie |0:

Podając |, mówisz tłumaczowi, aby wykonał operację binarną LUB. Operacje bitowe wymagają liczb bezwzględnych, które zamieniają wynik dziesiętny Date.now() / 1000na liczbę całkowitą.

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

Ostrzegamy: zamieni 64-bitową liczbę podwójną na 32-bitową liczbę całkowitą. Spowoduje to utratę informacji w przypadku dużych liczb. Znaczniki czasu zepsują się po 2038 r. Z powodu przepełnienia liczby całkowitej 32-bitowej.

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

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

jQuery zapewnia własną metodę uzyskiwania znacznika czasu:

var timestamp = $.now();

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

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

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

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

Aby dodać, oto funkcja zwracająca ciąg 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;
}

Data , natywny obiekt w JavaScript to sposób, w jaki uzyskujemy wszystkie dane o czasie.

Tylko bądź ostrożny w JavaScript, znacznik czasu zależy od zestawu komputerów klienckich, więc nie jest to 100% dokładny znacznik czasu. Aby uzyskać najlepszy wynik, musisz uzyskać znacznik czasu po stronie serwera .

W każdym razie moim ulubionym sposobem jest używanie wanilii. Jest to powszechny sposób robienia tego w JavaScript:

Date.now(); //return 1495255666921

W MDN jest to wymienione poniżej:

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

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

new Date().getTime();

Tego jeszcze nie widziałem

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

Kolejnym, którego jeszcze nie widziałem, jest

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

Date.getTime()Metoda może być stosowana z trochę uszczypnąć:

Wartość zwracana przez metodę getTime to liczba milisekund od 1 stycznia 1970 r. 00:00:00 UTC.

W floorrazie potrzeby podziel wynik przez 1000, aby uzyskać znacznik czasu Unix :

(new Date).getTime() / 1000

^{Date.valueOf()Metoda jest funkcjonalnie równoważne Date.getTime(), co sprawia, że można używać operatorów arytmetycznych w dniu wydania obiektu, aby osiągnąć identyczne wyniki. Moim zdaniem takie podejście wpływa na czytelność.}

Kod Math.floor(new Date().getTime() / 1000)można skrócić do new Date / 1E3 | 0.

Rozważ pominięcie bezpośredniego getTime()wywołania i użycie go | 0jako zamiennika Math.floor()funkcji. Warto również pamiętać, że 1E3jest to krótszy odpowiednik 1000(wielka litera E jest lepsza niż mała litera 1E3jako stała).

W rezultacie otrzymujesz:

var ts = new Date / 1E3 | 0;

console.log(ts);

Wydajność

Dzisiaj - 2020.04.23 Wykonuję testy dla wybranych rozwiązań. Testowałem na MacOs High Sierra 10.13.6 na Chrome 81.0, Safari 13.1, Firefox 75.0

Wnioski

• Rozwiązanie Date.now()(E) jest najszybsze w Chrome i Safari, a drugie szybkie w Firefox i jest to prawdopodobnie najlepszy wybór do szybkiego rozwiązania w różnych przeglądarkach
• performance.now()Co zaskakujące, rozwiązanie (G) jest ponad 100 razy szybsze niż inne rozwiązania w Firefoksie, ale najwolniejsze w Chrome
• Rozwiązania C, D, F działają dość wolno we wszystkich przeglądarkach

Detale

Wyniki dla chrome

Test możesz wykonać na swoim komputerze TUTAJ

Kod użyty w testach jest przedstawiony poniżej

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

Bardzo polecam korzystanie moment.js. Aby uzyskać liczbę milisekund od epoki UNIX, wykonaj:

moment().valueOf()

Aby uzyskać liczbę sekund od epoki UNIX, wykonaj:

moment().unix()

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

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

Robię to cały czas. Gra słów nie przeznaczona.

Aby użyć moment.jsw przeglądarce:

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

Aby uzyskać więcej informacji, w tym inne sposoby instalowania i używania MomentJS, zobacz ich dokumenty

Dla znacznika czasu o rozdzielczości mikrosekundowej dostępne są performance.now:

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

Może to na przykład przynieść zysk 1436140826653.139, a Date.nowjedynie daje 1436140826653.

Możesz tylko użyć

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

aby uzyskać bieżący znacznik czasu. Nie musisz robić nic więcej.

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

Wszelkie przeglądarki nieobsługiwane Date.now, możesz użyć tego, aby uzyskać bieżącą datę i godzinę:

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

Ten ma rozwiązanie: przekonwertuj unikstime stempel na tim w j wypróbuj to

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

Nauczyłem się naprawdę fajnego sposobu konwertowania danego obiektu Date na uniksowy znacznik czasu z kodu źródłowego JQuery Cookie innego dnia.

Oto przykład:

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

Jeśli chcesz podstawowy sposób generowania znacznika czasu w Node.js, działa to dobrze.

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

Nasz zespół używa tego do pomijania pamięci podręcznej w środowisku localhost. Dane wyjściowe to miejsce, w /dist/css/global.css?v=245521377którym 245521377generowany jest znacznik czasu hrtime().

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

To wydaje się 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);
            }
};

Jeśli jest to do celów logowania, możesz użyć ISOString

new Date().toISOString()

„2019-05-18T20: 02: 36.694Z”

W przypadku użytkowników lodash i podkreślników użyj _.now.

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

Moment.js może uśmierzyć wiele problemów związanych z JavaScript Dates.

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

moment().unix();

W chwili pisania tego tekstu najlepsza odpowiedź ma już 9 lat i od tego czasu wiele się zmieniło - mamy też prawie uniwersalne wsparcie dla niehackującego rozwiązania:

Date.now()

Jeśli chcesz mieć absolutną pewność, że nie złamie się to w jakiejś starożytnej (wcześniejszej niż 9) przeglądarce, możesz to sprawdzić za pomocą:

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

To zwróci milisekundy od czasu epoki, oczywiście, nie sekund.

Dokumentacja MDN na Date.now

prościej:

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