Comment obtenir un horodatage en JavaScript?

Quelque chose de similaire à l' horodatage Unix , c'est-à-dire un numéro unique qui représente l'heure et la date actuelles. Soit sous forme de nombre, soit sous forme de chaîne.

Court et élégant:

+ new Date()

Un opérateur unaire comme plusdéclenche la valueOfméthode dans l' Dateobjet et retourne l'horodatage (sans aucune modification).

Détails:

Sur presque tous les navigateurs actuels, vous pouvez utiliser Date.now()pour obtenir l'horodatage UTC en millisecondes ; une exception notable à cela est IE8 et versions antérieures (voir le tableau de compatibilité ).

Vous pouvez facilement créer une cale pour cela, cependant:

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

Pour obtenir l'horodatage en quelques secondes , vous pouvez utiliser:

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

Ou vous pouvez également utiliser:

Date.now() / 1000 | 0

Ce qui devrait être légèrement plus rapide, mais aussi moins lisible ( voir également cette réponse ).

Je recommanderais d'utiliser Date.now()(avec un module de compatibilité). C'est un peu mieux car il est plus court et ne crée pas de nouvel Dateobjet. Cependant, si vous ne voulez pas de cale et de compatibilité maximale, vous pouvez utiliser la "vieille" méthode pour obtenir l'horodatage en millisecondes :

new Date().getTime()

Que vous pouvez ensuite convertir en secondes comme ceci:

Math.round(new Date().getTime()/1000)

Et vous pouvez également utiliser la valueOfméthode que nous avons montrée ci-dessus:

new Date().valueOf()

Horodatage en millisecondes

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

J'aime ça, car c'est petit:

+new Date

J'aime aussi cela, car il est tout aussi court et compatible avec les navigateurs modernes, et plus de 500 personnes ont voté pour mieux:

Date.now()

JavaScript fonctionne avec le nombre de millisecondes depuis l'époque alors que la plupart des autres langues fonctionnent avec les secondes. Vous pouvez travailler avec des millisecondes mais dès que vous passez une valeur pour dire PHP, les fonctions natives PHP échoueront probablement. Donc, pour être sûr, j'utilise toujours les secondes, pas les millisecondes.

Cela vous donnera un horodatage Unix (en secondes):

var unix = Math.round(+new Date()/1000);

Cela vous donnera les millisecondes depuis l'époque (pas l'horodatage Unix):

var milliseconds = new Date().getTime();

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

time();

Je fournis plusieurs solutions avec des descriptions dans cette réponse. N'hésitez pas à poser des questions si quelque chose n'est pas clair
PS: malheureusement, quelqu'un a fusionné cela à la première réponse sans donner de crédit.

Solution rapide et sale:

Date.now() /1000 |0

Attention : il pourrait casser en 2038 et retourner des nombres négatifs si vous faites la |0magie. Utiliser à la Math.floor()place d'ici là

Math.floor() Solution:

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

Une alternative ringarde de Derek 朕 會 功夫 tirée des commentaires ci-dessous cette réponse:

new Date/1e3|0

Polyfill pour Date.now()travailler:

Pour le faire fonctionner dans IE, vous pouvez le faire (Polyfill de MDN ):

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

Si vous ne vous souciez pas de l'année / du jour de la semaine / de l'heure d'été, vous pouvez le retirer et l'utiliser après 2038:

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

Une sortie de ce à quoi il ressemblera:

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 )

Bien sûr, cela interrompra l'heure d'été, mais selon ce que vous construisez, cela peut vous être utile si vous devez effectuer des opérations binaires sur les horodatages après que int32 se soit interrompu en 2038.

Cela renverra également des valeurs négatives, mais uniquement si l'utilisateur de ce PC sur lequel vous exécutez votre code modifie l'horloge de son PC au moins au 31 décembre de l'année précédente.

Si vous voulez simplement connaître l'heure relative à partir du moment où le code a été exécuté en premier, vous pouvez utiliser quelque chose comme ceci:

var relativeTime = (function () {
    var start = Date.now();
    return function () {
        return Date.now() - start
    }
})();

Dans le cas où vous utilisez jQuery, vous pouvez utiliser $.now()comme décrit dans la documentation de jQuery, ce qui rend le polyfill obsolète car en $.now()interne fait la même chose:(new Date).getTime()

Si vous êtes simplement satisfait de la version de jQuery, pensez à voter pour cette réponse car je ne l'ai pas trouvée moi-même.

Maintenant, une petite explication de ce qui |0fait:

En fournissant |, vous dites à l'interprète d'effectuer une opération binaire OU. Les opérations sur les bits nécessitent des nombres absolus qui transforment le résultat décimal de Date.now() / 1000en un entier.

Au cours de cette conversion, les décimales sont supprimées, ce qui donne le même résultat que l'utilisation, Math.floor()mais en utilisant moins de code.

Soyez averti cependant: il convertira un double 64 bits en un entier 32 bits. Cela entraînera une perte d'informations lors du traitement d'un grand nombre. Les horodatages s'arrêteront après 2038 en raison d'un dépassement d'entier de 32 bits.

Pour plus d'informations sur Date.nowsuivez ce lien: Date.now()@ MDN

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

jQuery fournit sa propre méthode pour obtenir l'horodatage:

var timestamp = $.now();

^{(en plus il implémente simplement l' (new Date).getTime()expression)}

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

En plus des autres options, si vous voulez un ISO de format de date, vous pouvez l'obtenir directement

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

Juste pour additionner, voici une fonction pour retourner une chaîne d'horodatage en Javascript. Exemple: 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 , un objet natif en JavaScript est la façon dont nous obtenons toutes les données sur le temps.

Faites juste attention en JavaScript, l'horodatage dépend de l'ordinateur client, donc ce n'est pas un horodatage précis à 100%. Pour obtenir le meilleur résultat, vous devez obtenir l'horodatage côté serveur .

Quoi qu'il en soit, ma façon préférée est d'utiliser la vanille. C'est une façon courante de le faire en JavaScript:

Date.now(); //return 1495255666921

Dans MDN, il est mentionné comme ci-dessous:

La méthode Date.now () renvoie le nombre de millisecondes écoulées depuis le 1er janvier 1970 00:00:00 UTC.
Parce que now () est une méthode statique de Date, vous l'utilisez toujours comme Date.now ().

Si vous utilisez une version inférieure à ES5, Date.now();ne fonctionne pas et vous devez utiliser:

new Date().getTime();

Celui que je n'ai pas encore vu

Math.floor(Date.now() / 1000); // current time in seconds

Un autre que je n'ai pas encore vu est

var _ = require('lodash'); // from here https://lodash.com/docs#now
_.now();

La Date.getTime()méthode peut être utilisée avec un petit ajustement:

La valeur renvoyée par la méthode getTime est le nombre de millisecondes depuis le 1er janvier 1970 00:00:00 UTC.

Divisez le résultat par 1000 pour obtenir l'horodatage Unix, floorsi nécessaire:

(new Date).getTime() / 1000

^{La Date.valueOf()méthode est fonctionnellement équivalente à Date.getTime(), ce qui permet d'utiliser des opérateurs arithmétiques sur un objet date pour obtenir des résultats identiques. À mon avis, cette approche affecte la lisibilité.}

Le code Math.floor(new Date().getTime() / 1000)peut être raccourci new Date / 1E3 | 0.

Pensez à ignorer l' getTime()invocation directe et à l'utiliser | 0en remplacement de la Math.floor()fonction. Il est également bon de se rappeler que 1E3c'est un équivalent plus court pour 1000(les majuscules E sont préférées aux minuscules pour indiquer 1E3une constante).

En conséquence, vous obtenez les éléments suivants:

var ts = new Date / 1E3 | 0;

console.log(ts);

Performance

Aujourd'hui - 2020.04.23 J'effectue des tests pour les solutions choisies. J'ai testé sur MacOs High Sierra 10.13.6 sur Chrome 81.0, Safari 13.1, Firefox 75.0

Conclusions

• La solution Date.now()(E) est la plus rapide sur Chrome et Safari et la deuxième sur Firefox et c'est probablement le meilleur choix pour une solution rapide multi-navigateur
• La solution performance.now()(G), ce qui est surprenant, est plus de 100 fois plus rapide que les autres solutions sur Firefox mais la plus lente sur Chrome
• Les solutions C, D, F sont assez lentes sur tous les navigateurs

Détails

Résultats pour chrome

Vous pouvez effectuer des tests sur votre machine ICI

Le code utilisé dans les tests est présenté dans l'extrait ci-dessous

function A() {
  return new Date().getTime();
}

function B() {
  return new Date().valueOf();
}

function C() {
  return +new Date();
}

function D() {
  return new Date()*1;
}

function E() {
  return Date.now();
}

function F() {
  return Number(new Date());
}

function G() {
  // this solution returns time counted from loading the page.
  // (and on Chrome it gives better precission)
  return performance.now(); 
}



// TEST

log = (n,f) => console.log(`${n} : ${f()}`);

log('A',A);
log('B',B);
log('C',C);
log('D',D);
log('E',E);
log('F',F);
log('G',G);

This snippet only presents code used in external benchmark

Je recommande fortement d'utiliser moment.js. Pour obtenir le nombre de millisecondes depuis l'époque UNIX, faites

moment().valueOf()

Pour obtenir le nombre de secondes depuis l'époque UNIX, faites

moment().unix()

Vous pouvez également convertir des temps comme ceci:

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

Je fais ça tout le temps. Sans jeu de mots.

Pour utiliser moment.jsdans le navigateur:

<script src="moment.js"></script>
<script>
    moment().valueOf();
</script>

Pour plus de détails, y compris d'autres façons d'installer et d'utiliser MomentJS, consultez leurs documents

Pour un horodatage avec une résolution en microsecondes, il y a performance.now:

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

Cela pourrait par exemple céder 1436140826653.139, tout en Date.nowdonnant seulement 1436140826653.

Vous ne pouvez utiliser que

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

pour obtenir l'horodatage actuel. Pas besoin de faire plus.

Voici une fonction simple pour générer un horodatage au format: mm / jj / 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())));
}

Tous les navigateurs non pris en charge par Date.now, vous pouvez l'utiliser pour obtenir l'heure de la date actuelle:

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

Celui-ci a une solution: qui convertit le tampon unixtime en tim en js essayez ceci

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

L'autre jour, j'ai appris une façon vraiment cool de convertir un objet Date donné en un horodatage Unix à partir du code source de JQuery Cookie .

Voici un exemple:

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

Si vous voulez un moyen simple de générer un horodatage dans Node.js, cela fonctionne bien.

var time = process.hrtime();
var timestamp = Math.round( time[ 0 ] * 1e3 + time[ 1 ] / 1e6 );

Notre équipe l'utilise pour casser le cache dans un environnement local. La sortie est /dist/css/global.css?v=245521377où 245521377est l'horodatage généré par hrtime().

J'espère que cela aide, les méthodes ci-dessus peuvent également fonctionner, mais j'ai trouvé que c'était l'approche la plus simple pour nos besoins dans Node.js.

Cela semble fonctionner.

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

Si c'est à des fins de journalisation, vous pouvez utiliser ISOString

new Date().toISOString()

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

Pour les utilisateurs de lodash et de soulignement , utilisez _.now.

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

Moment.js peut éliminer une grande partie de la douleur liée au traitement des dates Javascript.

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

moment().unix();

Au moment d'écrire ces lignes, la première réponse a 9 ans et beaucoup de choses ont changé depuis - notamment, nous avons un support quasi universel pour une solution non hacky:

Date.now()

Si vous voulez être absolument certain que cela ne se cassera pas dans un ancien navigateur (avant ie9), vous pouvez le mettre derrière un chèque, comme ceci:

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

Cela retournera les millisecondes depuis le temps de l'époque, bien sûr, pas les secondes.

Documentation MDN sur Date.now

manière plus simple:

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