Wie bekomme ich einen Zeitstempel in JavaScript?

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 von 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 übergeben, um PHP zu sagen, werden die PHP systemeigenen Funktionen wahrscheinlich fehlschlagen. Um sicher zu gehen, benutze ich immer die Sekunden, nicht die 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();

In dieser Antwort stelle ich mehrere Lösungen mit Beschreibungen zur Verfügung. Fühlen Sie sich frei, Fragen zu stellen, wenn etwas unklar ist
PS: Leider hat dies jemand zur Top-Antwort zusammengeführt, ohne dass eine Anrechnung erfolgt ist.

Schnelle und schmutzige Lösung:

_Date.now() /1000 |0
_

Warnung : es könnte im Jahr 2038 brechen und negative Zahlen zurückgeben, wenn Sie den _|0_ Zauber. Verwenden Sie zu diesem Zeitpunkt stattdessen Math.floor()

Math.floor() solution:

_Math.floor(Date.now() /1000);
_

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

_new Date/1e3|0
_

Polyfill, um Date.now() zum Laufen zu bringen:

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

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

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

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

Einige Ergebnisse, 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 wird.

Dies gibt auch negative Werte zurück, aber nur, wenn der Benutzer des PCs, auf dem Sie Ihren Code ausführen, die Uhr seines PCs mindestens auf den 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 $.now() wie in jQuery's Docs beschrieben verwenden, wodurch die Polyfill veraltet, da $.now() intern dasselbe tut: _(new Date).getTime()_

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

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

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

Während dieser Konvertierung werden Dezimalstellen entfernt, was dasselbe Ergebnis wie bei der Verwendung von Math.floor() mit weniger Code ergibt.

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-Integer-Überlaufs unterbrochen.

Weitere Informationen zu _Date.now_ finden Sie unter folgendem Link: Date.now() @ MDN

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

jQuery liefert seine eigene Methode , um den Zeitstempel zu erhalten:

var timestamp = $.now();

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

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

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

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

Um nur zusammenzufassen, hier eine Funktion, um eine Zeitmarke in Javascript zurückzugeben. Beispiel: 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;
}

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

Seien Sie nur vorsichtig in JavaScript, der Zeitstempel hängt vom Client-Computersatz ab, daher ist der Zeitstempel nicht zu 100% korrekt. Um das beste Ergebnis zu erzielen, müssen Sie den Zeitstempel von Server-Seite erhalten. 

Wie auch immer, meine bevorzugte Methode ist die Verwendung von Vanille. Dies ist eine übliche Art und Weise, dies in JavaScript zu tun:

Date.now(); //return 1495255666921

In MDN wird es wie folgt erwähnt:

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

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

new Date().getTime();

Eine, die ich noch nicht gesehen habe 

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

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

Erwägen Sie das direkte getTime() - Aufruf zu überspringen und verwenden Sie | 0 als Ersatz für Math.floor() function ..__ Es ist auch gut sich zu erinnern, 1E3 ist ein kürzeres Äquivalent für 1000 (Großbuchstaben E wird als Kleinbuchstaben bevorzugt, um 1E3 as anzuzeigen eine Konstante).

Als Ergebnis erhalten Sie Folgendes:

var ts = new Date / 1E3 | 0;

console.log(ts);

Die Date.getTime() -Methode kann mit einem kleinen Tweak verwendet werden:

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

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

(new Date).getTime() / 1000

^{Die Date.valueOf()-Methode entspricht funktional Date.getTime(), wodurch arithmetische Operatoren am Date-Objekt verwendet werden können, um identische Ergebnisse zu erzielen. Meiner Meinung nach wirkt sich dieser Ansatz auf die Lesbarkeit aus.}

Ich empfehle die Verwendung von moment.js. Um die Anzahl der Millisekunden seit UNIX-Epoche zu ermitteln, tun Sie dies 

moment().valueOf()

Um die Anzahl der Sekunden seit UNIX-Epoche zu ermitteln, tun Sie

moment().unix()

Du kannst auch mal so konvertieren:

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

Das mache ich die ganze Zeit. Kein Wortspiel beabsichtigt.

moment.js im Browser verwenden:

<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 deren docs .

Hier ist eine einfache Funktion zum Erzeugen von Zeitstempeln 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())));
}

Sie können nur verwenden 

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

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

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

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

Dies könnte beispielsweise 1436140826653.139 ergeben, während Date.now nur 1436140826653 ergibt.

Alle Browser, die Date.now nicht unterstützen, können Sie hiermit das aktuelle Datum abrufen:

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

Heute - 2018.06.27 gebe ich einige Zeitvergleiche für reine js-Lösungen. Dies kann für Leute nützlich sein, die die Zeit in JS auf einfache und effiziente Weise abrufen/messen möchten (z. B. für Echtzeitanwendungen wie Simulationen, Spiele usw.).

Getestet auf MacOs High Sierra 10.13.3 unter Chrome 67.0.3396.99 (64-Bit), Safari 11.0.3 (13604.5.6), Firefox 59.0.2 (64-Bit). Auf dem folgenden Screenshot zeige ich Ihnen die Ergebnisse für den schnellsten Browser (Safari):

Wie ich beobachte, war Date.now() die schnellste Methode, um Zeitstempel für alle drei Browser zu erhalten. Safari hat 19,2 Millionen Operationen pro Sekunde, Firefox 16,1 Millionen, Chrome 7,8 Millionen. 

Die new Date()*1 war für Chrome (2.8M) und Firefox (2.6M) am langsamsten. Die Number(new Date()) war für Safari (2.9M) am langsamsten. 

Der Gewinner-JS-Code ist Date.now() und der schnellste Browser ist Safari (2x schneller als Chrome!). 

Sie können hier einen Test auf Ihrem Computer durchführen: https://jsperf.com/timestamp-test-x .

Ich habe eine wirklich coole Methode zum Konvertieren eines bestimmten Date-Objekts in einen Unix-Zeitstempel aus dem Quellcode von JQuery Cookie am anderen Tag gelernt.

Hier ist ein Beispiel:

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

Dieses hat eine Lösung: die Unix-Zeitmarke in js in js umwandelt, probiert dies aus

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

Wenn Sie einen einfachen Weg zum Erstellen eines Zeitstempels in Node.js wünschen, 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 localhost-Umgebung zu überbrücken. Die Ausgabe ist /dist/css/global.css?v=245521377, wobei 245521377 der von hrtime() generierte Zeitstempel ist. 

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

Verwenden Sie für lodash und Unterstrichen_.now.

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

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

Moment.js kann einen großen Teil des Schmerzes im Umgang mit Javascript-Dates beseitigen. 

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

moment().unix();

Zum jetzigen Zeitpunkt ist die beste Antwort neun Jahre alt, und seitdem hat sich viel verändert. Nicht zuletzt haben wir eine nahezu universelle Unterstützung für eine nicht hackige Lösung:

Date.now()

Wenn Sie absolut sicher sein möchten, dass dies nicht in einem alten Browser (vor der Version 9) beschädigt wird, können Sie es hinter einen Haken setzen:

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

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

MDN-Dokumentation zu Date.now

einfacher Weg:

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

manchmal brauche ich es in Objekten für xmlhttp-Aufrufe, also mag ich das.

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

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

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

Der empfohlene, richtige Weg ist Number(new Date()), In Bezug auf die Lesbarkeit des Codes.

Außerdem reduzieren UglifyJS und Google-Closure-Compiler die Komplexität des analysierten Code-Logik-Baums (relevant, wenn Sie einen von ihnen verwenden, um Ihren Code zu verschleiern). 

für Unix-Zeitstempel, der eine niedrigere Zeitauflösung hat, teilen Sie die aktuelle Zahl einfach mit 1000, und behalten Sie das Ganze bei. 

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

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

new Date().toISOString()

2019-05-18T20: 02: 36.694Z

Eine weitere Lösung zum Generieren eines Zeitstempels in JavaScript - einschließlich einer Auffüllmethode für einzelne Zahlen - mit Tag, Monat, Jahr, Stunde, Minute und Sekunden im Ergebnis (Arbeitsbeispiel bei 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);

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

>> Return current timestamp

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

>> Return required timestamp