Comment obtenez-vous un horodatage en JavaScript?
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. Soit un nombre ou une chaîne.
Short & Snazzy:
+ new Date()
Un opérateur unaire comme 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 dans milliseconds; Une exception notable à cette règle est IE8 et les versions antérieures (voir tableau de compatibilité ).
Vous pouvez facilement faire un shim 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)
Ou bien vous pouvez utiliser:
Date.now() / 1000 | 0
Ce qui devrait être un peu plus rapide, mais aussi moins lisible (aussi voir cette réponse ).
Je recommanderais d'utiliser Date.now() (avec compatibilité shim). C'est un peu mieux car il est plus court et ne crée pas de nouvel objet Date. Cependant, si vous ne voulez pas de compatibilité shim & maximum, vous pouvez utiliser la méthode "old" pour obtenir l'horodatage dans milliseconds:
new Date().getTime()
Que vous pouvez ensuite convertir en secondes comme ceci:
Math.round(new Date().getTime()/1000)
Et vous pouvez aussi utiliser la méthode valueOf 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, parce que c'est petit:
+new Date
J'aime aussi ça, car il est tout aussi court et compatible avec les navigateurs modernes, et plus de 500 personnes ont voté pour dire que c'est 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 transmettez une valeur pour dire PHP, les fonctions natives 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();
var time = Date.now || function() {
return +new Date;
};
time();
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 sale:
Date.now() /1000 |0
Avertissement: il pourrait se briser en 2038 et renvoyer des nombres négatifs si vous utilisez la magie
|0. UtilisezMath.floor()à la place à ce moment-là
_ {Math.floor() solution: _
Math.floor(Date.now() /1000);
Une alternative ringarde de Derek 會 功夫 tiré des commentaires ci-dessous cette réponse:
new Date/1e3|0
_ {Polyfill pour que Date.now() fonctionne: _
Pour que cela fonctionne dans IE, vous pouvez faire ceci (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 ou 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
}
})();
Quelques résultats sur 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, il passera l'heure d'été mais en fonction de ce que vous sont en train de construire cela pourrait vous être utile si vous avez besoin de faire du binaire les opérations sur les horodatages après int32 seront interrompues en 2038.
Cela renverra également des valeurs négatives, mais seulement si l'utilisateur de ce PC vous utilisez votre code change l'horloge de leur PC au moins à 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 Docs de jQuery , ce qui rend le polyfill obsolète puisque $.now() fait la même chose: (new Date).getTime()
Si vous êtes simplement content de la version de jQuery, envisagez de voter this answer 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ète d'effectuer une opération binaire OR. 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.
Au cours de cette conversion, les décimales sont supprimées, ce qui donne le même résultat que si vous utilisiez Math.floor() mais en utilisant moins de code.
Soyez averti cependant: il convertira un double de 64 bits en un entier de 32 bits. Cela se traduira par une perte d’information lorsqu’il s’agit de grands nombres. 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
var timestamp = Number(new Date()); // current time as number
jQuery fournit sa propre méthode pour obtenir l'horodatage:
var timestamp = $.now();
(à part cela implémente simplement l'expression (new Date).getTime())
console.log(new Date().valueOf()); // returns the number of milliseconds since the EpochJuste pour ajouter, voici une fonction permettant de renvoyer une chaîne d'horodatage en Javascript. Exemple: 15:06:38
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.
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, vous devez obtenir l’horodatage à partir de server-side .
Quoi qu'il en soit, ma méthode préférée consiste à utiliser Vanilla. 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();
Un 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();
Le code Math.floor(new Date().getTime() / 1000) peut être réduit à new Date / 1E3 | 0.
Pensez à ignorer les commandes directes getTime() invocation et à utiliser | 0 pour remplacer Math.floor() function . Il est également bon de se rappeler que 1E3 est un équivalent plus court de 1000 (la majuscule E est préférable à minuscule pour indiquer 1E3 comme une constante).
En conséquence, vous obtenez ce qui suit:
var ts = new Date / 1E3 | 0;
console.log(ts);La méthode Date.getTime() peut être utilisée avec un petit Tweak:
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 le timestamp Unix, floor 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 Date pour obtenir des résultats identiques. À mon avis, cette approche affecte la lisibilité.
Je recommande fortement d'utiliser moment.js. Pour obtenir le nombre de millisecondes depuis UNIX Epoch, faites
moment().valueOf()
Pour obtenir le nombre de secondes depuis UNIX Epoch, 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.js dans le navigateur:
<script src="moment.js"></script>
<script>
moment().valueOf();
</script>
Pour plus de détails, y compris d’autres manières d’installer et d’utiliser MomentJS, voir leurs docs
// 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>Voici une fonction simple pour générer l’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())));
}
Vous ne pouvez utiliser
var timestamp = new Date().getTime();
console.log(timestamp);pour obtenir l'horodatage actuel. Pas besoin de faire quelque chose de plus.
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 donner 1436140826653.139, alors que Date.now ne donne que 1436140826653.
Tous les navigateurs non supportés Date.now, vous pouvez l’utiliser pour obtenir la date et l’heure actuelles:
currentTime = Date.now() || +new Date()
Aujourd'hui - 2018.06.27, je propose une comparaison temporelle de solutions JS pures. Cela peut être utile pour les personnes qui souhaitent obtenir/mesurer le 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 montre les résultats pour le navigateur le plus rapide (Safari):
Comme je le constate, la 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.
La new Date()*1 était la plus lente pour Chrome (2,8M) et Firefox (2,6M). La Number(new Date()) était la plus lente pour Safari (2,9M).
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 machine ici: https://jsperf.com/timestamp-test-x .
J'ai appris un moyen vraiment cool de convertir un objet Date donné en un horodatage Unix à partir du code source de JQuery Cookie l'autre jour.
Voici un exemple:
var date = new Date();
var timestamp = +date;
Celui-ci a une solution: qui convertit l'horodatage Unix en heure en js
var a = new Date(UNIX_timestamp*1000);
var hour = a.getUTCHours();
var min = a.getUTCMinutes();
var sec = a.getUTCSeconds();
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 localhost. La sortie est /dist/css/global.css?v=245521377, où 245521377 est 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.
Pour lodash et underscore users, utilisez _.now.
var timestamp = _.now(); // in milliseconds
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);
}
};
Moment.js peut absorber une bonne 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 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 sans piratage:
Date.now()
Si vous voulez être absolument certain que cela ne se brisera pas dans un ancien navigateur (pre ie9), vous pouvez le placer derrière un chèque, comme ceci:
const currentTimestamp = (!Date.now ? +new Date() : Date.now());
Cela retournera les millisecondes depuis l'époque Epoch, bien sûr, pas les secondes.
manière plus simple:
var timeStamp=event.timestamp || new Date().getTime();
parfois, j'en ai besoin dans les objets pour les appels xmlhttp, alors je le fais comme ça.
timestamp : parseInt(new Date().getTime()/1000, 10)
var d = new Date();
console.log(d.valueOf());
La manière conseillée et appropriée est Number(new Date()), En termes de lisibilité du code,
De plus, UglifyJS et Google-Closure-Compiler réduiront la complexité de l’arbre logique-code-analysé (utile si vous utilisez l’un d’eux pour masquer/réduire le code).
pour l'horodatage Unix, qui a une résolution temporelle inférieure, divisez simplement le numéro actuel avec 1000, en conservant le tout.
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())));
}
Si c'est à des fins de journalisation, vous pouvez utiliser ISOString
new Date().toISOString()
"2019-05-18T20: 02: 36.694Z"
Voici une autre solution pour générer un horodatage en JavaScript - y compris une méthode de remplissage pour les nombres simples - en utilisant les résultats jour, mois, année, heure, minute et secondes (exemple de travail dans 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);
new Date().getTime(); and Date.now();
>> Return current timestamp
new Date("11/01/2018").getTime()
>> Return required timestamp