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.
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.
Réponses:
+ new Date()
Un opérateur unaire comme plus
déclenche la valueOf
méthode dans l' Date
objet 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 Date
objet. 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 valueOf
mé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());
~~(Date.now() / 1000)
Date.now()
+new Data
soit intelligent, il n'est pas lisible par d'autres développeurs. Date.now()
est plus clair et garantit que tout le monde sait ce qui se passe.
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()
new Date().getTime()
. Heureusement pour moi, la solution la plus rapide est déjà la solution lisible!
new Date().toString()
est appelé.
+
opérateur pour le faire sortir comme une ficelle?
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();
Unix timestamp
vs Seconds since the Epoch
. Ces deux ne sont-ils pas censés signifier la même chose?
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
|0
magie. Utiliser à laMath.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 |0
fait:
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() / 1000
en 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.now
suivez ce lien: Date.now()
@ MDN
Date.now()
référence: developer.mozilla.org/en-US/docs/JavaScript/Reference/…
new Date/1e3|0
.
jQuery fournit sa propre méthode pour obtenir l'horodatage:
var timestamp = $.now();
(en plus il implémente simplement l' (new Date).getTime()
expression)
parseInt
, car la valeur résultante sera toujours a Number
.
console.log(new Date().valueOf()); // returns the number of milliseconds since the epoch
+new Date
.. :)
Date.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());
new Date("2017-05-04T07:11:28.940Z") - new Date("2017-05-04T07:11:14.092Z")
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();
Date.now() /1000 |0
fait de même et a déjà reçu une réponse
Math.floor()
dedans mais seulement pour clarifier qu'il a le même effet que |0
. je ne voulais pas te faire de mal ou quoi que ce soit. Je voulais juste vous dire que votre réponse existe déjà d'une manière ou d'une autre. en regardant toutes les réponses données, il y en a qui remarquent le sol d'une manière ou d'une autre.
_.now()
est un peu exagérée. Je recommanderais seulement d'importer la fonctionnalité Lodash que vous devez utiliser (dans ce cas, _.now () sur NPM ), mais même ils ont déconseillé leur package au profit de leur utilisation Date.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, floor
si 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é.
new Date().getTime() / 1000
()
après new Date
et .getTime()
puisque de toute façon /
, l'objet Date sera converti en nombre.
Le code Math.floor(new Date().getTime() / 1000)
peut être raccourci new Date / 1E3 | 0
.
Pensez à ignorer l' getTime()
invocation directe et à l'utiliser | 0
en remplacement de la Math.floor()
fonction. Il est également bon de se rappeler que 1E3
c'est un équivalent plus court pour 1000
(les majuscules E sont préférées aux minuscules pour indiquer 1E3
une constante).
En conséquence, vous obtenez les éléments suivants:
var ts = new Date / 1E3 | 0;
console.log(ts);
"Math.floor(new Date().getTime()/1000)".length == 37;
"new Date/1E3|0".length == 14;
= 23 octets;
Math.floor()
par |0
rend ce code "clair et compréhensible". Expliquez-moi quel est l'intérêt de sauver 1 octet en le remplaçant 1000
par 1E3
. C'est ridicule. Je vois un mauvais code.
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
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-navigateurperformance.now()
(G), ce qui est surprenant, est plus de 100 fois plus rapide que les autres solutions sur Firefox mais la plus lente sur ChromeRé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
performance.now()
car il est censé être le plus précis en termes de tampon.
privacy.reduceTimerPrecision
qui arrondit les résultats à la milliseconde la plus proche. Il est également activé par défaut mais peut être désactivé. developer.mozilla.org/en-US/docs/Web/API/Performance/now
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.js
dans 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.now
donnant 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())));
}
(new (chain (-date) (to-i-s-o-string)))
.
// 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>
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()
Date.now
existe réellement (et est une fonction), avant de tenter de l' invoquer: currentTime = typeof Date.now === "function" ? Date.now() : +new Date()
.
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=245521377
où 245521377
est 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);
}
};
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();
moment().valueOf()
. Voir ma réponse.
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.
manière plus simple:
var timeStamp=event.timestamp || new Date().getTime();
event
vient. Vous devez donner une meilleure explication de la façon dont vous le résolvez au lieu d'écrire une réponse. S'il vous plaît!