Wie kann ich einen Zeitstempel in JavaScript erhalten?

Ähnlich wie beim Unix-Zeitstempel , dh eine einzelne Zahl, die die aktuelle Uhrzeit und das aktuelle Datum darstellt. Entweder als Zahl oder als Zeichenfolge.

Short & Snazzy:

+ new Date()

Ein unärer Operator wie pluslöst die valueOfMethode im DateObjekt aus und gibt den Zeitstempel zurück (ohne Änderung).

Einzelheiten:

In fast allen aktuellen Browsern können Sie Date.now()den UTC-Zeitstempel in Millisekunden abrufen . Eine bemerkenswerte Ausnahme ist IE8 und früher (siehe Kompatibilitätstabelle ).

Sie können jedoch leicht eine Unterlegscheibe dafür herstellen:

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

Um den Zeitstempel in Sekunden zu erhalten , können Sie Folgendes verwenden:

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

Oder alternativ könnten Sie verwenden:

Date.now() / 1000 | 0

Das sollte etwas schneller sein, aber auch weniger lesbar ( siehe auch diese Antwort ).

Ich würde empfehlen, Date.now()(mit Kompatibilitäts-Shim) zu verwenden. Es ist etwas besser, weil es kürzer ist und kein neues DateObjekt erstellt. Wenn Sie jedoch keine Unterlegscheibe und maximale Kompatibilität wünschen, können Sie die "alte" Methode verwenden, um den Zeitstempel in Millisekunden abzurufen :

new Date().getTime()

Was Sie dann wie folgt in Sekunden umrechnen können:

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

Sie können auch die oben gezeigte valueOfMethode verwenden:

new Date().valueOf()

Zeitstempel in Millisekunden

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

Ich mag das, weil es klein ist:

+new Date

Ich mag das auch, weil es genauso kurz ist und mit modernen Browsern kompatibel ist und über 500 Leute dafür gestimmt haben, dass es besser ist:

Date.now()

JavaScript arbeitet mit der Anzahl der Millisekunden seit der Epoche, während die meisten anderen Sprachen mit den Sekunden arbeiten. Sie könnten mit Millisekunden arbeiten, aber sobald Sie einen Wert für PHP übergeben, werden die nativen PHP-Funktionen wahrscheinlich fehlschlagen. Um sicher zu gehen, verwende ich immer die Sekunden, nicht Millisekunden.

Dadurch erhalten Sie einen Unix-Zeitstempel (in Sekunden):

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

Dies gibt Ihnen die Millisekunden seit der Epoche (nicht Unix-Zeitstempel):

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

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

time();

Ich biete mehrere Lösungen mit Beschreibungen in dieser Antwort. Fühlen Sie sich frei, Fragen zu stellen, wenn etwas unklar ist
PS: Leider hat jemand dies mit der Top-Antwort zusammengeführt, ohne Kredit zu geben.

Schnelle und schmutzige Lösung:

Date.now() /1000 |0

Warnung : Es könnte 2038 brechen und negative Zahlen zurückgeben, wenn Sie die |0Magie ausführen. Verwenden Sie Math.floor()stattdessen zu diesem Zeitpunkt

Math.floor() Lösung:

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

Eine nerdige Alternative von Derek 功夫 會 功夫 aus den Kommentaren unter dieser Antwort:

new Date/1e3|0

Polyfill zum Date.now()Arbeiten:

Um es im IE zum Laufen zu bringen, können Sie dies tun (Polyfill von MDN ):

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

Wenn Sie sich nicht für das Jahr / den Wochentag / die Sommerzeit interessieren, können Sie es entfernen und nach 2038 verwenden:

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

Einige Ausgaben, wie es aussehen wird:

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 )

Natürlich wird die Sommerzeit unterbrochen, aber je nachdem, was Sie erstellen, kann dies für Sie nützlich sein, wenn Sie Binäroperationen für Zeitstempel ausführen müssen, nachdem int32 im Jahr 2038 unterbrochen wurde.

Dies gibt auch negative Werte zurück, jedoch nur, wenn der Benutzer des PCs, auf dem Sie Ihren Code ausführen, die Uhr seines PCs mindestens bis zum 31. Dezember des Vorjahres ändert.

Wenn Sie nur die relative Zeit ab dem Zeitpunkt wissen möchten, an dem der Code zuerst ausgeführt wurde, können Sie Folgendes verwenden:

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

Wenn Sie jQuery verwenden, können Sie es $.now()wie in den Dokumenten von jQuery beschrieben verwenden , wodurch die Polyfüllung überflüssig wird, da $.now()intern dasselbe getan wird:(new Date).getTime()

Wenn Sie sich nur über die Version von jQuery freuen, sollten Sie diese Antwort positiv bewerten , da ich sie selbst nicht gefunden habe.

Nun eine kleine Erklärung dessen, was |0tut:

Durch Angabe weisen |Sie den Interpreter an, eine binäre ODER-Verknüpfung auszuführen. Bitoperationen erfordern absolute Zahlen, die das Dezimalergebnis von Date.now() / 1000in eine Ganzzahl umwandeln.

Während dieser Konvertierung werden Dezimalstellen entfernt, was zu demselben Ergebnis führt wie die Verwendung, Math.floor()jedoch mit weniger Code.

Seien Sie jedoch gewarnt: Es wird ein 64-Bit-Double in eine 32-Bit-Ganzzahl konvertiert. Dies führt zu Informationsverlust beim Umgang mit großen Zahlen. Zeitstempel werden nach 2038 aufgrund eines 32-Bit-Ganzzahlüberlaufs unterbrochen.

Weitere Informationen finden Sie unter Date.nowfolgendem Link: Date.now()@ MDN

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

jQuery bietet eine eigene Methode zum Abrufen des Zeitstempels:

var timestamp = $.now();

^{(außerdem implementiert es nur (new Date).getTime()Ausdruck)}

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

Zusätzlich zu den anderen Optionen können Sie eine Datumsformat-ISO direkt abrufen

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

Um es zusammenzufassen, hier ist eine Funktion, um eine Zeitstempelzeichenfolge in Javascript zurückzugeben. Beispiel: 15:06:38 Uhr

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

Datum , ein natives Objekt in JavaScript ist die Art und Weise, wie wir alle Daten über die Zeit erhalten.

Seien Sie in JavaScript nur vorsichtig, der Zeitstempel hängt vom Client-Computer ab, daher ist der Zeitstempel nicht 100% genau. Um das beste Ergebnis zu erzielen, müssen Sie den Zeitstempel von der Serverseite abrufen .

Wie auch immer, meine bevorzugte Art ist Vanille. Dies ist eine gängige Methode in JavaScript:

Date.now(); //return 1495255666921

In MDN wird es wie folgt erwähnt:

Die Date.now () -Methode gibt die Anzahl der Millisekunden zurück, die seit dem 1. Januar 1970 00:00:00 UTC vergangen sind.
Da now () eine statische Methode von Date ist, verwenden Sie sie immer als Date.now ().

Wenn Sie eine Version unter ES5 verwenden, Date.now();funktioniert dies nicht und Sie müssen Folgendes verwenden:

new Date().getTime();

Eine habe ich noch nicht gesehen

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

Eine andere, die ich noch nicht gesehen habe, ist

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

Die Date.getTime()Methode kann mit einer kleinen Änderung verwendet werden:

Der von der getTime-Methode zurückgegebene Wert gibt die Anzahl der Millisekunden seit dem 1. Januar 1970 um 00:00:00 UTC an.

Teilen Sie das Ergebnis durch 1000, um floorggf. den Unix-Zeitstempel zu erhalten :

(new Date).getTime() / 1000

^{Die Date.valueOf()Methode ist funktional äquivalent zu Date.getTime(), wodurch es möglich ist, arithmetische Operatoren für Datumsobjekte zu verwenden, um identische Ergebnisse zu erzielen. Meiner Meinung nach beeinträchtigt dieser Ansatz die Lesbarkeit.}

Der Code Math.floor(new Date().getTime() / 1000)kann auf gekürzt werden new Date / 1E3 | 0.

Überlegen Sie, den direkten getTime()Aufruf zu überspringen und | 0als Ersatz für die Math.floor()Funktion zu verwenden. Es ist auch gut zu bedenken, dass 1E3es sich um ein kürzeres Äquivalent für handelt 1000(Großbuchstabe E wird gegenüber Kleinbuchstaben bevorzugt, um 1E3als Konstante anzugeben ).

Als Ergebnis erhalten Sie Folgendes:

var ts = new Date / 1E3 | 0;

console.log(ts);

Performance

Heute - 2020.04.23 Ich führe Tests für ausgewählte Lösungen durch. Ich habe auf MacOs High Sierra 10.13.6 auf Chrome 81.0, Safari 13.1, Firefox 75.0 getestet

Schlussfolgerungen

• Lösung Date.now()(E) ist unter Chrome und Safari am schnellsten und unter Firefox am zweitschnellsten. Dies ist wahrscheinlich die beste Wahl für eine schnelle browserübergreifende Lösung
• Die performance.now()überraschende Lösung (G) ist mehr als 100-mal schneller als andere Lösungen in Firefox, in Chrome jedoch am langsamsten
• Die Lösungen C, D, F sind in allen Browsern ziemlich langsam

Einzelheiten

Ergebnisse für Chrom

Sie können HIER einen Test auf Ihrem Computer durchführen

Der in Tests verwendete Code ist im folgenden Snippet dargestellt

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

Ich kann die Verwendung nur empfehlen moment.js. Führen Sie die folgenden Schritte aus, um die Anzahl der Millisekunden seit der UNIX-Epoche abzurufen

moment().valueOf()

Führen Sie die folgenden Schritte aus, um die Anzahl der Sekunden seit der UNIX-Epoche abzurufen

moment().unix()

Sie können auch Zeiten wie folgt konvertieren:

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

Das mache ich die ganze Zeit. Kein Wortspiel beabsichtigt.

So verwenden Sie es moment.jsim Browser:

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

Weitere Informationen, einschließlich anderer Möglichkeiten zur Installation und Verwendung von MomentJS, finden Sie in den entsprechenden Dokumenten

Für einen Zeitstempel mit Mikrosekundenauflösung gibt es performance.now:

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

Dies könnte zum Beispiel ergeben 1436140826653.139, während Date.nownur gibt 1436140826653.

Sie können nur verwenden

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

um den aktuellen Zeitstempel zu erhalten. Sie müssen nichts extra tun.

Hier ist eine einfache Funktion zum Generieren eines Zeitstempels im Format: mm / tt / jj 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())));
}

Alle Browser, die Date.now nicht unterstützen, können Sie verwenden, um die aktuelle Datums- und Uhrzeitangabe abzurufen:

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

Dieser hat eine Lösung: die Unixtime-Stempel in js konvertiert in js versuchen Sie dies

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

Ich habe neulich aus dem Quellcode von JQuery Cookie eine wirklich coole Art gelernt, ein bestimmtes Date-Objekt in einen Unix-Zeitstempel zu konvertieren .

Hier ist ein Beispiel:

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

Wenn Sie einen einfachen Weg zum Generieren eines Zeitstempels in Node.js suchen, funktioniert dies gut.

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

Unser Team verwendet dies, um den Cache in einer lokalen Host-Umgebung zu sprengen. Die Ausgabe ist, /dist/css/global.css?v=245521377wo 245521377der Zeitstempel von erzeugt wird hrtime().

Hoffentlich hilft dies, die oben genannten Methoden können auch funktionieren, aber ich fand, dass dies der einfachste Ansatz für unsere Anforderungen in Node.js ist.

Das scheint zu funktionieren.

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

Wenn es zu Protokollierungszwecken dient, können Sie ISOString verwenden

new Date().toISOString()

2019-05-18T20: 02: 36.694Z

Für lodash und Unterstreichungs Benutzer, verwenden _.now.

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

Moment.js kann einen Großteil des Schmerzes im Umgang mit Javascript-Daten abstrahieren.

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

moment().unix();

Zum Zeitpunkt des Schreibens ist die Top-Antwort 9 Jahre alt, und seitdem hat sich viel geändert - nicht zuletzt haben wir nahezu universelle Unterstützung für eine nicht hackige Lösung:

Date.now()

Wenn Sie absolut sicher sein möchten, dass dies in einem alten Browser (vor ie9) nicht funktioniert, können Sie ihn wie folgt hinter einen Scheck stellen:

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

Dies gibt die Millisekunden seit der Epoche zurück, natürlich nicht Sekunden.

MDN-Dokumentation am Date.now

einfacher Weg:

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