data - pila javascript




Come si ottiene un timestamp in JavaScript? (20)

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 (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 usare:

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

In alternativa puoi usare:

Date.now() / 1000 | 0

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

Vorrei raccomandare l'uso di Date.now() (con shim di compatibilità). È leggermente migliore perché è più breve e non crea un nuovo oggetto Date . Tuttavia, se non si desidera uno spessore 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 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());

Come posso ottenere un timestamp in JavaScript?

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


Al momento della stesura di questo, la risposta migliore è di 9 anni, e da allora è cambiato molto, non ultimo, abbiamo quasi un 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 storico, ovviamente, non secondi.

MDN


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

Giusto per aggiungere, 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;
}

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

Considera di saltare la Date.getTime() diretta Date.getTime() e usa | 0 | 0 in sostituzione della funzione Math.floor() . È anche bene ricordare che 1E3 è un equivalente più breve per 1000 (maiuscolo E preferito da minuscolo per indicare 1E3 come costante).

Di conseguenza ottieni quanto segue:

var ts = new Date / 1E3 | 0;

console.log(ts);


Il metodo Date.getTime() può essere utilizzato con un piccolo ritocco:

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

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

(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. A mio parere, questo approccio influenza la leggibilità.


Mi piace, perché è piccolo:

+new Date

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

Date.now()

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):

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

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



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

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

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


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

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

Questo ha una soluzione: che converte timbro unixtime in tim in js prova questo

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

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.


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

modo più semplice:

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


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

Attenzione : potrebbe rompersi nel 2038 e restituire numeri negativi se si esegue la magia |0 . Usa Math.floor() invece per quel momento

Soluzione Math.floor() :

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

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

new Date/1e3|0

Polyfill per ottenere Date.now() funzionante:

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 / 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 a seconda di ciò che si sta creando potrebbe essere utile se si devono eseguire operazioni binarie su timestamp dopo la rottura di int32 nel 2038.

Ciò restituirà anche valori negativi, ma solo se l'utente di quel PC su cui stai eseguendo il tuo codice sta cambiando l'orologio del PC almeno fino 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 tu stia usando jQuery puoi usare $.now() come descritto nei documenti di jQuery che rende il polyfill obsoleto da $.now() internamente fa la stessa cosa: (new Date).getTime()

Se sei felice della versione di jQuery, considera l'inversione di this risposta poiché non l'ho trovata io stesso.

Ora una piccola spiegazione di cosa fa |0 :

Fornendo | , dici all'interprete di fare un'operazione OR binaria. Le operazioni bit richiedono numeri assoluti che convertono 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.

Attenzione 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: MDN


L' oggetto nativo di date in JavaScript è il modo in cui otteniamo tutti i dati sul tempo.

Basta fare attenzione in JavaScript il timestamp dipende dalle impostazioni del 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.
Perché now () è un metodo statico di Date, lo si utilizza sempre come Date.now ().

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

new Date().getTime();

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


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

time();




unix-timestamp