Come si ottiene un timestamp in JavaScript?
https://stackoverflow.com/questions/221294
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
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 numero o stringa.
Soluzione
Short & amp; Snazzy:
+ new Date()
Un operatore unario come plus attiva il metodo valueOf nell'oggetto Date e restituisce il timestamp (senza alcuna modifica).
Dettagli:
Su quasi tutti i browser attuali puoi utilizzare Date.now () per ottenere il timestamp UTC in millisecondi ; un'eccezione notevole a questa è IE8 e precedenti (vedi 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 secondi , puoi 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 (anche vedi questa risposta ).
Consiglierei di usare Date.now () (con shim di compatibilità). È leggermente meglio perché è più corto e amp; non crea un nuovo oggetto Date . Tuttavia, se non vuoi uno spessore & amp; massima compatibilità, puoi utilizzare il "vecchio" metodo 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 metodo valueOf che abbiamo mostrato sopra:
new Date().valueOf()
Timestamp 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());
Altri suggerimenti
Mi piace, 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()
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();
var time = Date.now || function() {
return +new Date;
};
time();
Fornisco soluzioni multiple 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
Avvertenza : potrebbe rompersi nel 2038 e restituire numeri negativi se si esegue il
| 0magia. UsaMath.floor ()invece a quel punto
Soluzione Math.floor () :
Math.floor(Date.now() /1000);
Qualche alternativa nerd di Derek & # 26389; & # 26371; & # 21371; & # 21151; & # 22827; tratti dal commenti sotto questa risposta:
new Date/1e3|0
Polyfill per far funzionare Date.now () :
Per farlo funzionare in IE puoi farlo (Polyfill da MDN ):
if (!Date.now) {
Date.now = function now() {
return new Date().getTime();
};
}
Se non ti interessa l'anno / il giorno della settimana / l'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 appariranno:
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 stai costruendo questo potrebbe esserti utile se devi fare binario le operazioni sui timestamp dopo int32 si interromperanno nel 2038.
Questo restituirà anche valori negativi, ma solo se l'utente di quel PC su cui stai eseguendo il codice sta cambiando almeno l'orologio del loro PC 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 utilizzi jQuery, è possibile utilizzare $ .now () come descritto in jQuery's Docs che rende obsoleto il polyfill poiché $ .now () fa internamente la stessa cosa: (nuova data) .getTime ()
Se sei solo felice della versione di jQuery, considera la possibilità di votare questa poiché non l'ho trovata me stesso.
Ora una piccola spiegazione di cosa fa | 0 :
Fornendo | , si dice all'interprete di eseguire un'operazione OR binaria. Le operazioni sui bit richiedono numeri assoluti che trasformano il risultato decimale da Date.now () / 1000 in un numero intero.
Durante quella conversione, i decimali vengono rimossi, ottenendo lo stesso risultato dell'uso di Math.floor () ma utilizzando meno codice.
Attenzione però: convertirà un doppio da 64 bit in un intero da 32 bit. Ciò comporterà la perdita di informazioni quando si gestiscono numeri enormi. I timestamp si interromperanno dopo il 2038 a causa di un overflow di numeri interi a 32 bit.
Per ulteriori informazioni su Date.now segui questo link: Date.now () @ MDN
var timestamp = Number(new Date()); // current time as number
jQuery fornisce il proprio metodo per ottenere il timestamp:
var timestamp = $.now();
(oltre a implementa solo (nuova data) .getTime () espressione)
console.log(new Date().valueOf()); // returns the number of milliseconds since the epoch
Giusto 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;
}
Oltre alle altre opzioni, se desideri un formato data ISO, puoi ottenerlo direttamente
console.log(new Date().toISOString());
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 .
Comunque, 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 da allora 1 gennaio 1970 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();
Il Date.getTime () il metodo può essere usato 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 di Unix,
(new Date).getTime() / 1000
Il metodo Date.valueOf () è funzionalmente equivalente a Date.getTime () , che consente di utilizzare operatori aritmetici sull'oggetto data per ottenere risultati identici. A mio avviso, questo approccio influisce sulla leggibilità.
Il codice Math.floor (new Date (). getTime () / 1000) può essere abbreviato in new Date / 1E3 | 0 .
Considera di saltare direttamente getTime () invocazione e utilizzare | 0 in sostituzione di Math .floor () .
È anche bene ricordare che 1E3 è un equivalente più breve per 1000 (la E maiuscola è preferita alla minuscola per indicare 1E3 come costante).
Di conseguenza si ottiene quanto segue:
var ts = new Date / 1E3 | 0;
console.log(ts);
Consiglio vivamente di usare moment.js . Per ottenere il numero di millisecondi dall'epoca di UNIX, fai
moment().valueOf()
Per ottenere il numero di secondi dall'epoca di UNIX, eseguire
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 ulteriori dettagli, inclusi altri modi di installazione e utilizzo di MomentJS, consultare i loro documenti
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())));
}
// 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>
Puoi usare solo
var timestamp = new Date().getTime();
console.log(timestamp);
per ottenere il timestamp corrente. Non c'è bisogno di fare altro.
Per un timestamp con risoluzione di microsecondi, c'è performance .Ora :
function time() {
return performance.now() + performance.timing.navigationStart;
}
Questo potrebbe ad esempio produrre 1436140826653.139 , mentre Date.now fornisce solo 1436140826653 .
Oggi - 2018.06.27 Fornisco un confronto temporale per le soluzioni js pure. Questo può essere utile per le persone che vogliono ottenere / misurare il tempo in JS in modo leggero / efficiente (ad es. Per applicazioni in tempo reale come simulazioni, giochi ecc.)
Testato su MacOs High Sierra 10.13.3 su Chrome 67.0.3396.99 (64-bit), Safari 11.0.3 (13604.5.6), Firefox 59.0.2 (64-bit). Nella schermata qui sotto ti mostro i risultati per il browser più veloce (Safari):
Come osservo il Date.now () è stato il metodo più veloce per ottenere il timestamp per tutti e tre i browser. Safari ha 19,2 milioni di operazioni al secondo, Firefox 16,1 milioni, Chrome 7,8 milioni.
Il new Date () * 1 è stato il più lento per Chrome (2.8M) e Firefox (2.6M). Il Number (new Date ()) era più lento per Safari (2.9M).
Quindi il codice JS vincitore è Date.now () e il browser più veloce è Safari (2x più veloce di Chrome!).
Puoi eseguire i test sulla tua macchina qui: https://jsperf.com/timestamp-test-x .
Tutti i browser non supportati Date.now, puoi utilizzarlo per ottenere l'ora della data corrente:
currentTime = Date.now() || +new Date()
Questo ha una soluzione: che converte timestamp unix in time in js provalo
var a = new Date(UNIX_timestamp*1000);
var hour = a.getUTCHours();
var min = a.getUTCMinutes();
var sec = a.getUTCSeconds();
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 scoperto 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 lodash e trattino basso utenti, usano _.now .
var timestamp = _.now(); // in milliseconds
Moment.js può sottrarre gran parte del dolore nel gestire le date Javascript.
Vedi: http://momentjs.com/docs/#/displaying/unix -timestamp /
moment().unix();
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());
Questo restituirà i millisecondi dal tempo dell'epoca, ovviamente, non i secondi.
modo più semplice:
var timeStamp=event.timestamp || new Date().getTime();
qualche volta ne ho bisogno negli oggetti per le chiamate xmlhttp, quindi mi piace.
timestamp : parseInt(new Date().getTime()/1000, 10)
