date timestamp - Comment obtenez-vous un horodatage en JavaScript?




converter js (25)

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.


Answers

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


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


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


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


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

Pensez à ignorer l' Date.getTime() directe de Date.getTime() et à l'utiliser | 0 | 0 en remplacement de la fonction Math.floor() . Il est également bon de se rappeler que 1E3 est un équivalent plus court pour 1000 (la majuscule E est préférable à la minuscule pour indiquer 1E3 tant que constante).

En conséquence, vous obtenez ce qui suit:

var ts = new Date / 1E3 | 0;

console.log(ts);


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

time();

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 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 montre les résultats pour le 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.

La new Date()*1 était la plus lente pour Chrome (2,8M) et Firefox (2,6M). Le Number(new Date()) était le plus lent pour Safari (2,9M).

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

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


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 .


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

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

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

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)

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

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


manière plus simple:

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

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

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

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



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;

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


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

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

Maintenant, vous pouvez tirer parti de la syntaxe ES6 et faire simplement:

let array = [1, 2];
console.log([...array, 3]);

garder le tableau d'origine immuable.





javascript date datetime timestamp unix-timestamp