it-swarm.dev

Come si ottiene un timestamp in JavaScript?

Come posso ottenere un timestamp in JavaScript?

Qualcosa di simile al timestamp Unix, cioè un numero singolo che rappresenta l'ora e la data attuali. O come numero o stringa.

3576
pupeno

Breve e Snazzy:

+ new Date()

Un operatore unario come plus attiva il metodo valueOf nell'oggetto Date e restituisce il timestamp (senza alcuna alterazione).

Dettagli:

Su quasi tutti i browser correnti puoi usare Date.now() per ottenere il timestamp UTC in millisecondi; una notevole eccezione a questo è IE8 e precedenti (vedere 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 seconds, puoi utilizzare:

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

O in alternativa puoi usare:

Date.now() / 1000 | 0

Quale dovrebbe essere leggermente più veloce, ma anche meno leggibile (anche vedere questa risposta ).

Consiglierei di usare Date.now() (con shim di compatibilità). È leggermente migliore perché è più breve e non crea un nuovo oggetto Date. Tuttavia, se non vuoi uno spessore e la massima compatibilità, puoi usare 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 metodo valueOf che abbiamo mostrato sopra:

new Date().valueOf()

Timestamp in Milliseconds

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

4438
daveb

Mi piace, perché è piccolo:

+new Date

Mi piace anche questo, perché è altrettanto breve ed è compatibile con i browser moderni, e oltre 500 persone hanno votato che è meglio: 

Date.now()
459
xer0x

JavaScript funziona con il numero di millisecondi dall'Epoch mentre la maggior parte degli altri linguaggi funziona con i secondi. Si potrebbe lavorare con millisecondi ma non appena si passa un valore per dire PHP, le funzioni native PHP probabilmente falliranno. Quindi per essere sicuro di usare 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 dalla Epoch (non dal timestamp Unix):

var milliseconds = new Date().getTime();
248
Daithí
var time = Date.now || function() {
  return +new Date;
};

time();
133
Staale

Fornisco più soluzioni con descrizioni in questa risposta. Sentiti libero di fare domande se qualcosa non è chiaro
PS: purtroppo qualcuno lo ha unito alla risposta principale senza dare credito.


Soluzione rapida e sporca:

Date.now() /1000 |0

Avvertenza: it potrebbe irrompere nel 2038 e restituire numeri negativi se si esegue la magia |0. Utilizzare Math.floor() invece entro quell'ora

Math.floor() soluzione:

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

Qualche alternativa nerd di Derek 朕 會 功夫 tratto dai commenti sotto questa risposta:

new Date/1e3|0

Polyfill per ottenere Date.now() working:

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/giorno della settimana/l'ora legale puoi eliminarlo e utilizzarlo dopo il 2038: 

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

Qualche risultato su 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 )

Ovviamente interromperà l'ora legale ma dipende da cosa tu costruire questo potrebbe esserti utile se hai bisogno di fare binari le operazioni sui timestamp dopo l'int32 si interromperanno nel 2038.

Ciò restituirà anche valori negativi, ma solo se l'utente di quel PC stai facendo funzionare il tuo codice sta cambiando il loro orologio del PC almeno a 31 dicembre dell'anno precedente.


Se vuoi solo conoscere 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 tu stia usando jQuery puoi usare $.now() come descritto in jQuery's Docs che rende obsoleto il polyfill poiché $.now() internamente fa la stessa cosa: (new Date).getTime()

Se sei felice della versione di jQuery, considera l'upvoting this answer poiché non l'ho trovato io stesso.


Ora una piccola spiegazione di cosa fa |0:

Fornendo |, comunichi all'interprete di eseguire un'operazione OR binaria. Le operazioni bit richiedono numeri assoluti che trasformano il risultato decimale da Date.now() / 1000 in un numero intero. 

Durante questa conversione, i decimali vengono rimossi, con lo stesso risultato dell'uso di Math.floor() ma utilizzando meno codice.

Stai attento però: convertirà un doppio da 64 bit in un intero a 32 bit. Ciò si tradurrà in perdita di informazioni quando si tratta di numeri enormi. I timestamp si interromperanno dopo il 2038 a causa di un overflow intero a 32 bit.


Per ulteriori informazioni su Date.now segui questo link: Date.now() @ MDN

112
GottZ
var timestamp = Number(new Date()); // current time as number
77
aemkei

jQuery fornisce il proprio metodo per ottenere il timestamp:

var timestamp = $.now();

(oltre a implementare l'espressione (new Date).getTime())

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

56
VisioN

console.log(new Date().valueOf()); // returns the number of milliseconds since the Epoch

39
Tom Viner

Solo per sommare, ecco una funzione per restituire una stringa di 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;
}
38
live-love

Oltre alle altre opzioni, se si desidera una dataformat ISO, è possibile ottenerla direttamente

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

36

Date, un oggetto nativo in JavaScript è il modo in cui otteniamo tutti i dati sul tempo.

Basta fare attenzione in JavaScript il timestamp dipende dal set del computer client, quindi non è un timestamp accurato al 100%. Per ottenere il miglior risultato, è necessario ottenere il timestamp da lato server

Ad ogni modo, il mio modo preferito è usare Vanilla. 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 1 gennaio 1970 00:00:00 UTC.
Perché now () è un metodo statico di Date, lo si utilizza sempre come Date.now ().

Se usi una versione sotto ES5, Date.now(); non funziona e devi usare:

new Date().getTime();
28
Alireza

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

Il codice Math.floor(new Date().getTime() / 1000) può essere abbreviato in new Date / 1E3 | 0.

Considera saltare l'invocazione diretta getTime() e usare | 0 come sostituto per Math.floor() function . È anche bene ricordare 1E3 è un equivalente più breve per 1000 (maiuscolo E è preferito del minuscolo per indicare 1E3 as una costante).

Di conseguenza ottieni quanto segue:

var ts = new Date / 1E3 | 0;

console.log(ts);

24
Valentin

Il metodo Date.getTime() può essere usato con un piccolo Tweak:

Il valore restituito dal metodo getTime è il numero di millisecondi dal 1 ° gennaio 1970 alle 00:00:00 UTC.

Dividere il risultato per 1000 per ottenere il timestamp di Unix, floor se necessario:

(new Date).getTime() / 1000

Il metodo Date.valueOf() è funzionalmente equivalente a Date.getTime(), che consente di utilizzare operatori aritmetici su un oggetto data per ottenere risultati identici. Secondo me, questo approccio influenza la leggibilità.

24
Salman A

Consiglio vivamente di utilizzare moment.js. Per ottenere il numero di millisecondi da UNIX Epoch, fare 

moment().valueOf()

Per ottenere il numero di secondi da quando UNIX Epoch, 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 ulteriori dettagli, inclusi altri modi di installare e utilizzare MomentJS, vedere i loro documenti

20
FullStack

// 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>

19
blueberry0xff

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

Puoi solo usarlo 

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

per ottenere il timestamp corrente. Non c'è bisogno di fare nulla in più.

19
Jitendra Pawar

Per un timestamp con risoluzione al microsecondo, c'è performance.now :

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

Questo potrebbe per esempio rendere 1436140826653.139, mentre Date.now dà solo 1436140826653.

17
iter

Qualsiasi browser non supportato Date.now, puoi utilizzarlo per ottenere l'ora corrente della data:

currentTime = Date.now() || +new Date()
15
mr.boyfox

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 esempio per applicazioni in tempo reale come simulazioni, giochi, ecc.)

Testato su Mac OS 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). Sotto lo screenshot vi mostro i risultati per il browser più veloce (Safari):

 enter image description here

Come osservo 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.1M, Chrome 7.8M. 

new Date()*1 è stato il più lento per Chrome (2,8M) e Firefox (2,6M). 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!). 

È possibile eseguire test sulla macchina qui: https://jsperf.com/timestamp-test-x .

15

Ho imparato un modo davvero interessante di convertire un dato 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;
13
george

Se vuoi un modo semplice 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 sta usando questo per distruggere 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, i metodi di cui sopra possono funzionare bene, ma ho trovato questo è l'approccio più semplice per le nostre esigenze in Node.js.

13
Kevin Leary

Per lodash e underscore users, usa _.now.

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

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);
            }
};
12
Ron Royston

Moment.js può astrarre molto del dolore nel trattare le date di Javascript. 

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

moment().unix();
9
Rimian

Al momento della stesura di questo, la risposta migliore è di 9 anni, e da allora è cambiato molto, non ultimo, abbiamo quasi il supporto universale per una soluzione non hacky:

Date.now()

Se vuoi essere assolutamente certo che questo non si romperà in un browser antico (pre ie9), puoi metterlo dietro un assegno, in questo modo:

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

Ciò restituirà i millisecondi dal momento in cui Epoch, ovviamente, non secondi.

Documentazione MDN su Date.now

9
Olemak

modo più semplice:

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

a volte ho bisogno di oggetti per le chiamate xmlhttp, quindi mi piace questo.

timestamp : parseInt(new Date().getTime()/1000, 10)
5
DevC
var d = new Date();
console.log(d.valueOf()); 
3
jameslouiz

Il modo corretto e consigliato è Number(new Date()), In termini di leggibilità del codice,

Inoltre, UglifyJS e Google-Closure-Compiler abbasseranno la complessità del codice logico analizzato (rilevante se si sta utilizzando uno di essi per oscurare/minificare il codice). 

per il timestamp Unix, che ha una risoluzione temporale inferiore, basta dividere il numero corrente con 1000, mantenendo il tutto. 

3
user257319

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

2
Eugene
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())));
}
1
unknown123

Se è per scopi di registrazione, puoi usare ISOString

new Date().toISOString()

"2019-05-18T20: 02: 36.694Z"

1
cenkarioz

Ecco un'altra soluzione per generare un timestamp in JavaScript - incluso un metodo di riempimento per numeri singoli - utilizzando giorno, mese, anno, ora, minuto e secondi nel suo risultato (esempio di lavoro in 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);
0
Saucier
new Date().getTime(); and Date.now();

>> Return current timestamp

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

>> Return required timestamp
0
ashish