Come posso ottenere un timestamp in JavaScript?
Qualcosa di simile al timestamp di Unix , ovvero un singolo numero che rappresenta l'ora e la data correnti. O come un numero o una stringa.
Come posso ottenere un timestamp in JavaScript?
Qualcosa di simile al timestamp di Unix , ovvero un singolo numero che rappresenta l'ora e la data correnti. O come un numero o una stringa.
Risposte:
+ new Date()
Un operatore unario come plus
innesca il valueOf
metodo Date
nell'oggetto e restituisce il timestamp (senza alcuna alterazione).
Dettagli:
Su quasi tutti i browser attuali è possibile utilizzare Date.now()
per ottenere il timestamp UTC in millisecondi ; un'eccezione notevole a questa è IE8 e precedenti (vedere la tabella di compatibilità ).
Puoi facilmente fare uno shim per questo, però:
if (!Date.now) {
Date.now = function() { return new Date().getTime(); }
}
Per ottenere il timestamp in pochi secondi , è possibile utilizzare:
Math.floor(Date.now() / 1000)
O in alternativa puoi usare:
Date.now() / 1000 | 0
Che dovrebbe essere leggermente più veloce, ma anche meno leggibile ( vedi anche questa risposta ).
Consiglio di utilizzare Date.now()
(con shim di compatibilità). È leggermente meglio perché è più corto e non crea un nuovo Date
oggetto. Tuttavia, se non si desidera uno shim e la massima compatibilità, è possibile utilizzare il metodo "vecchio" per ottenere il timestamp in millisecondi :
new Date().getTime()
Che puoi quindi convertire in secondi come questo:
Math.round(new Date().getTime()/1000)
E puoi anche usare il valueOf
metodo che abbiamo mostrato sopra:
new Date().valueOf()
Data e ora in millisecondi
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());
Date.now() / 1000 | 0
soffrirai del problema dell'anno 2038 ? new Date('Jan 1, 2039') / 1000 | 0 == -2117514496
~~(Date.now() / 1000)
Date.now()
+new Data
è intelligente, non è leggibile da altri sviluppatori. Date.now()
è più chiaro e garantisce che tutti gli altri sappiano cosa sta succedendo.
Mi piace questo, perché è piccolo:
+new Date
Mi piace anche questo, perché è altrettanto corto ed è compatibile con i browser moderni e oltre 500 persone hanno votato che è meglio:
Date.now()
new Date().getTime()
. Fortunatamente per me, la soluzione più veloce è già la soluzione leggibile!
new Date().toString()
viene chiamato.
+
facendo l' operatore per farlo uscire come una corda?
JavaScript funziona con il numero di millisecondi dall'epoca, mentre la maggior parte delle altre lingue funziona con i secondi. Potresti lavorare con millisecondi ma non appena passi un valore per dire PHP, le funzioni native di PHP probabilmente falliranno. Quindi, per essere sicuro, utilizzo sempre i secondi, non i millisecondi.
Questo ti darà un timestamp Unix (in secondi):
var unix = Math.round(+new Date()/1000);
Questo ti darà i millisecondi dall'epoca (non il timestamp di Unix):
var milliseconds = new Date().getTime();
Unix timestamp
vs Seconds since the Epoch
. Questi due non dovrebbero significare la stessa cosa?
var time = Date.now || function() {
return +new Date;
};
time();
Fornisco più soluzioni con descrizioni in questa risposta. Sentiti libero di fare domande se qualcosa non è chiaro
PS: purtroppo qualcuno ha unito questo alla risposta migliore senza dare credito.
Soluzione rapida e sporca:
Date.now() /1000 |0
Attenzione : potrebbe rompersi nel 2038 e restituire numeri negativi se fai la
|0
magia. UsaMath.floor()
invece entro quel momento
Math.floor()
soluzione:
Math.floor(Date.now() /1000);
Qualche alternativa nerd di Derek 朕 會 功夫 presa dai commenti sotto questa risposta:
new Date/1e3|0
Polyfill per iniziare a Date.now()
lavorare:
Per farlo funzionare in IE è possibile farlo (Polyfill da MDN ):
if (!Date.now) {
Date.now = function now() {
return new Date().getTime();
};
}
Se non ti interessa l'anno / giorno della settimana / ora legale, puoi rimuoverlo e usarlo dopo il 2038:
var now = (function () {
var year = new Date(new Date().getFullYear().toString()).getTime();
return function () {
return Date.now() - year
}
})();
Alcuni risultati di come apparirà:
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 )
Naturalmente si romperà l'ora legale, ma a seconda di ciò che si sta costruendo questo potrebbe essere utile se è necessario eseguire operazioni binarie su timestamp dopo che int32 si interromperà nel 2038.
Ciò restituirà anche valori negativi ma solo se l'utente di quel PC su cui stai eseguendo il codice sta cambiando l'orologio del suo PC almeno al 31 dicembre dell'anno precedente.
Se vuoi solo sapere il tempo relativo dal momento in cui il codice è stato eseguito per primo, potresti usare qualcosa del genere:
var relativeTime = (function () {
var start = Date.now();
return function () {
return Date.now() - start
}
})();
Nel caso in cui si stia utilizzando jQuery, è possibile utilizzare $.now()
come descritto in Documenti di jQuery, il che rende obsoleto il polyfill poiché $.now()
internamente fa la stessa cosa:(new Date).getTime()
Se sei solo felice della versione di jQuery, considera la possibilità di aggiungere questa risposta poiché non l'ho trovata da solo.
Ora una piccola spiegazione di cosa |0
fa:
Fornendo |
, si dice all'interprete di eseguire un'operazione OR binaria. Le operazioni sui bit richiedono numeri assoluti che trasformano il risultato decimale Date.now() / 1000
in un numero intero.
Durante tale conversione, i decimali vengono rimossi, con lo stesso risultato dell'utilizzo Math.floor()
ma dell'utilizzo di meno codice.
Attenzione però: convertirà un doppio a 64 bit in un intero a 32 bit. Ciò comporterà la perdita di informazioni quando si gestiscono numeri enormi. I timestamp si interromperanno dopo il 2038 a causa dell'overflow di numeri interi a 32 bit.
Per ulteriori informazioni su Date.now
seguire questo link: Date.now()
@ MDN
Date.now()
riferimento: developer.mozilla.org/en-US/docs/JavaScript/Reference/…
new Date/1e3|0
.
jQuery fornisce il proprio metodo per ottenere il timestamp:
var timestamp = $.now();
(inoltre implementa solo l' (new Date).getTime()
espressione)
parseInt
, poiché il valore risultante sarà sempre a Number
.
console.log(new Date().valueOf()); // returns the number of milliseconds since the epoch
+new Date
.. :)
Date.now()
Oltre alle altre opzioni, se desideri un formato data ISO, puoi ottenerlo direttamente
console.log(new Date().toISOString());
new Date("2017-05-04T07:11:28.940Z") - new Date("2017-05-04T07:11:14.092Z")
Solo per aggiungere, ecco una funzione per restituire una stringa timestamp in Javascript. Esempio: 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 , un oggetto nativo in JavaScript è il modo in cui otteniamo tutti i dati sul tempo.
Fai solo attenzione a JavaScript, il timestamp dipende dal set di computer client, quindi non è un timestamp accurato al 100%. Per ottenere il miglior risultato, è necessario ottenere il timestamp dal lato server .
Ad ogni modo, il mio modo preferito è usare la vaniglia. Questo è un modo comune di farlo in JavaScript:
Date.now(); //return 1495255666921
In MDN è menzionato come di seguito:
Il metodo Date.now () restituisce il numero di millisecondi trascorsi dal 1 ° gennaio 1970 alle 00:00:00 UTC.
Poiché now () è un metodo statico di Date, lo usi sempre come Date.now ().
Se si utilizza una versione inferiore a ES5, Date.now();
non funziona e è necessario utilizzare:
new Date().getTime();
Uno che non ho ancora visto
Math.floor(Date.now() / 1000); // current time in seconds
Un altro che non ho ancora visto è
var _ = require('lodash'); // from here https://lodash.com/docs#now
_.now();
Date.now() /1000 |0
fa lo stesso ed è stato risposto in precedenza
Math.floor()
in esso, ma solo per chiarire che ha lo stesso effetto di |0
. non volevo ferirti o altro. volevo solo dirti che la tua risposta esiste già in qualche modo. guardando tutte le risposte fornite ce ne sono alcune che notano il pavimento in qualche modo.
_.now()
sia un po 'eccessivo. Consiglierei solo di importare la funzionalità Lodash che devi usare (in questo caso, _.now () su NPM ), ma anche loro hanno deprecato il loro pacchetto in favore del solo utilizzo Date.now()
.
Il Date.getTime()
metodo può essere utilizzato con una piccola modifica:
Il valore restituito dal metodo getTime è il numero di millisecondi dal 1 ° gennaio 1970 alle 00:00:00 UTC.
Dividi il risultato per 1000 per ottenere il timestamp Unix, floor
se necessario:
(new Date).getTime() / 1000
Il Date.valueOf()
metodo è funzionalmente equivalente a Date.getTime()
, il che rende possibile utilizzare operatori aritmetici sull'oggetto data per ottenere risultati identici. Secondo me, questo approccio influisce sulla leggibilità.
new Date().getTime() / 1000
()
dopo new Date
e .getTime()
dato che /
lancerà comunque l'oggetto Date in un numero.
Il codice Math.floor(new Date().getTime() / 1000)
può essere abbreviato in new Date / 1E3 | 0
.
Considera di saltare l' getTime()
invocazione diretta e utilizzarla | 0
come sostituto della Math.floor()
funzione. È anche bene ricordare che 1E3
è un equivalente più breve per 1000
(la E maiuscola è preferibile alla minuscola per indicare 1E3
come costante).
Di conseguenza si ottiene quanto segue:
var ts = new Date / 1E3 | 0;
console.log(ts);
"Math.floor(new Date().getTime()/1000)".length == 37;
"new Date/1E3|0".length == 14;
37 -14 = 23 byte;
Math.floor()
di |0
sta rendendo questo codice "chiaro e comprensibile". Spiegami qual è il punto per salvare 1 byte sostituendolo 1000
con 1E3
. Questo è ridicolo. Vedo un codice errato.
Oggi - 2020.04.23 Eseguo test per le soluzioni scelte. Ho provato su MacO High Sierra 10.13.6 su Chrome 81.0, Safari 13.1, Firefox 75.0
Date.now()
(E) è la più veloce su Chrome e Safari e la seconda veloce su Firefox e questa è probabilmente la scelta migliore per una soluzione cross-browser veloceperformance.now()
(G), ciò che sorprende, è oltre 100 volte più veloce di altre soluzioni su Firefox ma più lenta su ChromeRisultati per Chrome
È possibile eseguire il test sulla macchina QUI
Il codice utilizzato nei test è presentato nello snippet di seguito
performance.now()
in quanto dovrebbe essere il più preciso in termini di timbro.
privacy.reduceTimerPrecision
che arrotonda i risultati al millisecondo più vicino. Inoltre è abilitato di default ma può essere disabilitato. developer.mozilla.org/en-US/docs/Web/API/Performance/now
Consiglio vivamente di usare moment.js
. Per ottenere il numero di millisecondi dall'epoca di UNIX, fare
moment().valueOf()
Per ottenere il numero di secondi dall'epoca UNIX, fare
moment().unix()
Puoi anche convertire i tempi in questo modo:
moment('2015-07-12 14:59:23', 'YYYY-MM-DD HH:mm:ss').valueOf()
Lo faccio sempre. Nessun gioco di parole previsto.
Per utilizzare moment.js
nel browser:
<script src="moment.js"></script>
<script>
moment().valueOf();
</script>
Per maggiori dettagli, inclusi altri modi di installazione e utilizzo di MomentJS, consultare i loro documenti
Per un timestamp con risoluzione di microsecondi, c'è performance.now
:
function time() {
return performance.now() + performance.timing.navigationStart;
}
Questo potrebbe ad esempio cedere 1436140826653.139
, mentre Date.now
dà solo 1436140826653
.
Puoi solo usare
var timestamp = new Date().getTime();
console.log(timestamp);
per ottenere il timestamp corrente. Non c'è bisogno di fare altro.
Ecco una semplice funzione per generare il timestamp nel formato: mm / gg / aa 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())));
}
(new (chain (-date) (to-i-s-o-string)))
.
// 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>
Qualsiasi browser non supportato Date.now, è possibile utilizzarlo per ottenere l'ora della data corrente:
currentTime = Date.now() || +new Date()
Date.now
esiste realmente (ed è una funzione), prima di tentare di invocarlo: currentTime = typeof Date.now === "function" ? Date.now() : +new Date()
.
Ho imparato un modo davvero interessante di convertire un determinato oggetto Date in un timestamp Unix dal codice sorgente di JQuery Cookie l'altro giorno.
Ecco un esempio:
var date = new Date();
var timestamp = +date;
Se vuoi un modo base per generare un timestamp in Node.js, questo funziona bene.
var time = process.hrtime();
var timestamp = Math.round( time[ 0 ] * 1e3 + time[ 1 ] / 1e6 );
Il nostro team lo sta usando per bloccare la cache in un ambiente localhost. L'output è /dist/css/global.css?v=245521377
dove 245521377
è il timestamp generato da hrtime()
.
Speriamo che questo aiuti, anche i metodi sopra possono funzionare ma ho trovato che questo è l'approccio più semplice per le nostre esigenze in Node.js.
Questo sembra funzionare.
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);
}
};
Per gli utenti lodash e underscore , utilizzare _.now
.
var timestamp = _.now(); // in milliseconds
Moment.js può sottrarre gran parte del dolore nel gestire le date di Javascript.
Vedi: http://momentjs.com/docs/#/displaying/unix-timestamp/
moment().unix();
moment().valueOf()
. Vedi la mia risposta
Al momento della stesura di questo, la risposta migliore ha 9 anni e da allora molte cose sono cambiate - non da ultimo, abbiamo un supporto quasi universale per una soluzione non confusa:
Date.now()
Se vuoi essere assolutamente certo che questo non si romperà in alcuni browser antichi (pre ie9), puoi metterlo dietro un segno di spunta, in questo modo:
const currentTimestamp = (!Date.now ? +new Date() : Date.now());
Ciò restituirà i millisecondi dal tempo dell'epoca, ovviamente, non dai secondi.
modo più semplice:
var timeStamp=event.timestamp || new Date().getTime();
event
viene. Devi dare una spiegazione migliore del modo in cui la risolvi invece di scrivere una risposta. Per favore!