yyyy - Comment obtenez-vous un horodatage en JavaScript?




timestamp to hour javascript (20)

Comment puis-je obtenir un horodatage en JavaScript?

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

https://code.i-harness.com


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 en millisecondes ; Une exception notable à cette règle est IE8 et les versions antérieures (voir le 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 ( voir aussi cette réponse ).

Je recommanderais d'utiliser Date.now() (avec compatibilité shim). C'est légèrement mieux parce que c'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 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 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());


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 se brisera pas dans un ancien navigateur (pre 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 l'époque, bien sûr, pas les secondes.

MDN


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

Celui-ci a une solution: qui convertit timbre 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();

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;

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

Je recommande fortement d'utiliser moment.js . Pour obtenir le nombre de millisecondes depuis l’époque UNIX, effectuez la procédure suivante:

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 méthodes d’installation et d’utilisation de MomentJS, consultez leur docs


La méthode Date.getTime() 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 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 l’objet date pour obtenir des résultats identiques. À mon avis, cette approche affecte la lisibilité.


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)

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

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 .


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=245521377245521377 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é que c’était l’approche la plus simple pour nos besoins dans Node.js.


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

Voici une fonction simple pour générer un timestamp 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())));
}

manière plus simple:

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


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

Attention : cela pourrait casser en 2038 et renvoyer des nombres négatifs si vous faites la magie |0 . Utilisez Math.floor() place

Math.floor() :

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

Une alternative ringarde de Derek 功夫 會 功夫 extraite 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 le supprimer 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, cela annulera l'heure d'été, mais en fonction de ce que vous construisez, cela peut vous être utile si vous devez effectuer des opérations binaires sur des horodatages après la fermeture de l'int32 en 2038.

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

Si vous voulez juste 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() interne fait la même chose: (new Date).getTime()

Si vous êtes simplement content de la version de jQuery, envisagez de faire voter this réponse car je ne l'ai pas trouvée moi-même.

Maintenant, une petite explication de ce que fait |0

En fournissant | , vous dites à l’interprète de faire une opération OU binaire. Les opérations sur les bits nécessitent des nombres absolus qui Date.now() / 1000 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 lorsque vous utilisez Math.floor() mais avec 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: MDN


La date d' 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 du paramètre de l'ordinateur client. Il ne s'agit donc pas d'un horodatage précis à 100%. Pour obtenir le meilleur résultat, vous devez obtenir l'horodatage du côté serveur .

Quoi qu'il en soit, ma méthode préférée consiste à utiliser la vanille. C'est une manière 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 le 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();

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


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

time();




unix-timestamp