Comment obtenez-vous un horodatage en JavaScript?

Question

Comment puis-je obtenir un horodatage en JavaScript?

Quelque chose de semblable à l’horodatage Unix, c’est-à-dire un nombre unique représentant l’heure et la date actuelles. Sous forme de nombre ou de chaîne.

Answer 1

Court & amp; Snazzy:

+ new Date()

Un opérateur unaire tel que plus déclenche la méthode valueOf dans l'objet Date et renvoie 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 ; IE8 et ses versions antérieures constituent une exception notable (voir le tableau de compatibilité ). .

Vous pouvez facilement faire une cale pour cela, cependant:

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

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

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

Sinon, vous pouvez utiliser:

Date.now() / 1000 | 0

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

Je vous recommanderais d'utiliser Date.now () (avec compatibilité shim). C'est un peu mieux parce que c'est plus court & amp; ne crée pas de nouvel objet Date . Cependant, si vous ne voulez pas de shim & amp; compatibilité maximale, vous pouvez utiliser le " ancien " méthode permettant d’obtenir l’horodatage en millisecondes :

new Date().getTime()

Ce que vous pouvez ensuite convertir en secondes comme ceci:

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

Et vous pouvez également utiliser la méthode valueOf décrite 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());

Answer 2

J'aime ça, parce que c'est petit:

+new Date

J'aime aussi ça, car il est tout aussi court et compatible avec les navigateurs modernes. Plus de 500 personnes ont voté pour que ce soit mieux:

Date.now()

Answer 3

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

Cela vous donnera un timestamp 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();

Answer 4

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

time();

Answer 5

Je propose 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 pour donner la meilleure réponse sans donner de crédit.

Solution rapide et incorrecte:

Date.now() /1000 |0

  

Avertissement : il pourrait se briser en 2038 et renvoyer des nombres négatifs si vous exécutez le | 0 magie. Utilisez plutôt Math.floor () à cette heure-là

Solution Math.floor () :

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

Une alternative ringarde de Derek & # 26389; & # 26371; & # 21151; & # 22827; extraite du commentaires en dessous de cette réponse:

new Date/1e3|0

Polyfill pour que Date.now () fonctionne:

Pour que cela fonctionne dans IE, vous pouvez le faire (Polyfill from 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 l'enlever et l'utiliser après 2038:

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

  

Voici un aperçu de son apparence:

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 passera à l’heure avancée mais en fonction de ce que vous   construisons cela pourrait vous être utile si vous avez besoin de faire binaire   les opérations sur les horodatages après int32 seront interrompues en 2038.

     

Ceci renverra également des valeurs négatives mais uniquement si l'utilisateur de ce PC   vous utilisez votre code change l'horloge de leur PC au moins pour   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
    }
})();

Si vous utilisez jQuery, vous pouvez utiliser $. now () comme décrit dans la documentation de jQuery qui rend le polyfill obsolète puisque $. now () fait la même chose en interne: (nouvelle date) .getTime ()

Si vous êtes simplement satisfait de la version de jQuery, envisagez de ce répondre car je ne l'ai pas trouvé. moi-même.

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

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

Lors de cette conversion, les décimales sont supprimées, ce qui a le même résultat que d'utiliser Math.floor () mais avec moins de code.

  

Soyez averti cependant: il convertira un double de 64 bits en un entier de 32 bits. Cela entraînera une perte d’information lorsqu’il s’agit de nombres énormes. Les horodatages seront interrompus après 2038 en raison d'un débordement d'entier de 32 bits.

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

Answer 6

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

Answer 7

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

var timestamp = $.now();

^{(en plus de cela, il ne fait que mettre en œuvre l'expression (nouvelle date) .getTime () )}

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

Answer 8

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

Answer 9

Pour ajouter quelque chose, voici une fonction permettant de renvoyer une chaîne d'horodatage en Javascript. Exemple: 15h06: 38h

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

Answer 10

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

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

Answer 11

Date , un objet natif en JavaScript permet d’obtenir toutes les données sur le temps.

Faites attention en JavaScript, l'horodatage dépend de l'ensemble des ordinateurs clients. Il ne s'agit donc pas d'un horodatage précis à 100%. Pour obtenir le meilleur résultat possible, vous devez obtenir l'horodatage du serveur .

Quoi qu’il en soit, ma méthode préférée est l’utilisation de la vanille. C’est une façon courante de le faire en JavaScript:

Date.now(); //return 1495255666921

Dans MDN, il est mentionné ci-dessous:

  

La méthode Date.now () renvoie le nombre de millisecondes écoulées depuis   1er janvier 1970 00:00:00 UTC.
  Comme 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();

Answer 12

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

Answer 13

Le Date.getTime () La 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, étage si nécessaire:

(new Date).getTime() / 1000

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

Answer 14

Le code Math.floor (new Date (). getTime () / 1000) peut être abrégé en new Date / 1E3 | 0 .

Envisagez de passer directement au getTime () invocation et utilisation | 0 en remplacement de Math .floor () . Il est également bon de se rappeler que 1E3 est un équivalent plus court de 1000 (la majuscule E est préférable à la minuscule pour indiquer 1E3 comme constante).

Par conséquent, vous obtenez le texte suivant:

var ts = new Date / 1E3 | 0;

console.log(ts);

Answer 15

Je recommande vivement d'utiliser moment.js . Pour obtenir le nombre de millisecondes depuis la période UNIX, effectuez

moment().valueOf()

Pour connaître le nombre de secondes écoulées depuis l'époque UNIX, effectuez

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 le fais tout le temps. Sans jeu de mots.

Pour utiliser moment.js dans le navigateur:

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

Pour plus de détails, y compris d'autres méthodes d'installation et d'utilisation de MomentJS, consultez leur docs

.

Answer 16

Voici une fonction simple permettant de 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())));
}

Answer 17

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

Answer 18

Vous ne pouvez utiliser que

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

pour obtenir l’horodatage actuel. Pas besoin de faire quelque chose de plus.

Answer 19

Pour un horodatage avec une résolution en microsecondes, les performances .now :

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

Cela pourrait par exemple générer 1436140826653.139 , tandis que Date.now ne donne que 1436140826653 .

Answer 20

Aujourd'hui - 2018.06.27 Je fournis une comparaison temporelle des solutions JS pures. Cela peut être utile pour les personnes qui souhaitent obtenir / mesurer du temps dans JS de manière légère / efficace (par exemple, pour des applications en temps réel telles que des simulations, des jeux, etc.)

Testé sur MacOs High Sierra 10.13.3 sur Chrome 67.0.3396.99 (64 bits), Safari 11.0.3 (13604.5.6), Firefox 59.0.2 (64 bits). Sur la capture d'écran ci-dessous, je vous présente les résultats du navigateur le plus rapide (Safari):

Comme je le constate, Date.now () est la méthode la plus rapide pour obtenir l’horodatage des trois navigateurs. Safari a 19,2 millions d'opérations par seconde, Firefox 16,1 millions, Chrome 7,8 millions.

Le nouveau Date () * 1 était le plus lent pour Chrome (2,8M) et Firefox (2,6M). Le numéro (nouvelle date ()) était le plus lent pour Safari (2,9 Mo).

Le code JS gagnant est donc Date.now () et le navigateur le plus rapide est Safari (2x plus rapide que chrome!).

Vous pouvez effectuer des tests sur votre ordinateur ici: https://jsperf.com/timestamp-test-x .

Answer 21

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

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

Answer 22

Celui-ci a une solution: qui convertit l’horodatage Unix en heure en js, essayez ceci

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

Answer 23

J'ai appris à partir du code source de Cookie JQuery l’autre jour.

Voici un exemple:

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

Answer 24

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 détruire le cache dans un environnement hôte local. La sortie est /dist/css/global.css?v=245521377 où 245521377 correspond à l'horodatage généré par hrtime () .

Espérons que cela aide, les méthodes ci-dessus peuvent aussi fonctionner, mais j’ai trouvé cette approche la plus simple pour nos besoins dans Node.js.

Answer 25

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

Answer 26

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

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

Answer 27

Moment.js peut faire oublier beaucoup de difficultés à gérer les dates Javascript.

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

moment().unix();

Answer 28

Au moment d’écrire ceci, la meilleure réponse est celle de 9 ans, et beaucoup de choses ont changé depuis - nous ne manquons pas de soutien quasi universel pour une solution non-hacky:

Date.now()

Si vous voulez être absolument certain que cela ne casse pas dans un navigateur ancien (antérieur à ie9), vous pouvez le placer derrière un chèque, comme suit:

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

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

Documentation MDN sur Date.now

Answer 29

plus simple:

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

Answer 30

j’en ai parfois besoin dans les objets pour les appels xmlhttp, donc je l’aime comme ça.

timestamp : parseInt(new Date().getTime()/1000, 10)