Lors de l'écriture d'une application Web, il est logique de stocker (côté serveur) toutes les heures de données dans la base de données en tant qu'horodatages UTC.

J'ai été étonné de constater que vous ne pouviez pas faire grand-chose en natif en termes de manipulation du fuseau horaire en JavaScript.

J'ai un peu étendu l'objet Date. Cette fonction a-t-elle un sens? En gros, chaque fois que j'envoie quelque chose au serveur, ça va être un horodatage formaté avec cette fonction ...

Pouvez-vous voir des problèmes majeurs ici? Ou peut-être une solution sous un angle différent?

Date.prototype.getUTCTime = function(){ 
  return new Date(
    this.getUTCFullYear(),
    this.getUTCMonth(),
    this.getUTCDate(),
    this.getUTCHours(),
    this.getUTCMinutes(), 
    this.getUTCSeconds()
  ).getTime(); 
}

Cela me semble un peu compliqué. Et je ne suis pas non plus si sûr des performances.

1. Les dates construites de cette façon utilisent le fuseau horaire local, ce qui rend la date construite incorrecte. Pour définir le fuseau horaire d'un certain objet de date, il faut le construire à partir d'une chaîne de date qui inclut le fuseau horaire. (J'ai eu des problèmes pour faire fonctionner cela dans un ancien navigateur Android.)

2. Notez que getTime()renvoie des millisecondes, pas des secondes simples.

Pour un horodatage UTC / Unix, ce qui suit devrait suffire:

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

Il prendra en compte le décalage du fuseau horaire actuel dans le résultat. Pour une représentation sous forme de chaîne, la réponse de David Ellis fonctionne.

Clarifier:

new Date(Y, M, D, h, m, s)

Cette entrée est traitée comme l'heure locale . Si l' heure UTC est passée, les résultats seront différents. Observez (je suis actuellement à GMT +02: 00, et il est 07:50):

> var d1 = new Date();
> d1.toUTCString();
"Sun, 18 Mar 2012 05:50:34 GMT" // two hours less than my local time
> Math.floor(d1.getTime()/ 1000)
1332049834 

> var d2 = new Date( d1.getUTCFullYear(), d1.getUTCMonth(), d1.getUTCDate(), d1.getUTCHours(), d1.getUTCMinutes(), d1.getUTCSeconds() );
> d2.toUTCString();
"Sun, 18 Mar 2012 03:50:34 GMT" // four hours less than my local time, and two hours less than the original time - because my GMT+2 input was interpreted as GMT+0!
> Math.floor(d2.getTime()/ 1000)
1332042634

Notez également que getUTCDate()cela ne peut pas être remplacé getUTCDay(). C'est parce que getUTCDate()renvoie le jour du mois ; tandis que, getUTCDay()renvoie le jour de la semaine .

Vous pouvez également le faire en utilisant getTimezoneOffset et getTime,

x = new Date()
var UTCseconds = (x.getTime() + x.getTimezoneOffset()*60*1000)/1000;

console.log("UTCseconds", UTCseconds)

Le moyen le plus simple d'obtenir l'heure UTC dans un format conventionnel est le suivant:

new Date().toISOString()
"2016-06-03T23:15:33.008Z"

Je pense en fait que les valeurs de date dans js sont bien meilleures que les objets C # DateTime. Les objets C # DateTime ont une propriété Kind, mais aucun fuseau horaire sous-jacent strict en tant que tel, et les conversions de fuseau horaire sont difficiles à suivre si vous effectuez une conversion entre deux heures non UTC et non locales. Dans js, toutes les valeurs Date ont une valeur UTC sous-jacente qui est transmise et connue indépendamment des conversions offest ou de fuseau horaire que vous effectuez. Ma plus grande plainte à propos de l'objet Date est la quantité de comportement non défini que les implémenteurs de navigateur ont choisi d'inclure, ce qui peut confondre les personnes qui attaquent les dates dans js avec des essais et des erreurs que la lecture des spécifications. L'utilisation de quelque chose comme iso8601.js résout ce comportement variable en définissant une seule implémentation de l'objet Date.

Par défaut, la spécification dit que vous pouvez créer des dates avec un format de date ISO 8601 étendu comme

var someDate = new Date('2010-12-12T12:00Z');

Ainsi, vous pouvez déduire l'heure UTC exacte de cette façon.

Lorsque vous souhaitez renvoyer la valeur Date au serveur que vous appelleriez

someDate.toISOString();

ou si vous préférez travailler avec un horodatage en millisecondes (nombre de millisecondes à partir du 1er janvier 1970 UTC)

someDate.getTime();

ISO 8601 est une norme. Vous ne pouvez pas être confus sur ce que signifie une chaîne de date si vous incluez le décalage de date. Ce que cela signifie pour vous en tant que développeur, c'est que vous n'avez jamais à gérer vous-même les conversions d'heure locale . Les valeurs d'heure locale existent uniquement pour le bénéfice de l'utilisateur, et les valeurs de date s'affichent par défaut dans leur heure locale. Toutes les manipulations de l'heure locale vous permettent d'afficher quelque chose de sensible pour l'utilisateur et de convertir des chaînes à partir de l'entrée utilisateur. C'est une bonne pratique de convertir en UTC dès que vous le pouvez, et l'objet js Date rend cela assez trivial.

En revanche, il n'y a pas beaucoup de possibilités de forcer le fuseau horaire ou les paramètres régionaux pour le client (dont je suis conscient), ce qui peut être ennuyeux pour les paramètres spécifiques au site Web, mais je suppose que le raisonnement derrière cela est qu'il s'agit d'un utilisateur configuration à ne pas toucher.

Donc, en bref, la raison pour laquelle il n'y a pas beaucoup de support natif pour la manipulation de fuseau horaire est que vous ne voulez tout simplement pas le faire.

Vous n'avez généralement pas besoin de faire beaucoup de "manipulation du fuseau horaire" côté client. En règle générale, j'essaie de stocker et de travailler avec des dates UTC, sous la forme de ticks" nombre de millisecondes depuis minuit le 1er janvier 1970 ". Cela simplifie vraiment le stockage, le tri, le calcul des décalages, et surtout, vous évite le mal de tête des ajustements "Daylight Saving Time". Voici un petit code JavaScript que j'utilise.

Pour obtenir l'heure UTC actuelle:

function getCurrentTimeUTC()
{
    //RETURN:
    //      = number of milliseconds between current UTC time and midnight of January 1, 1970
    var tmLoc = new Date();
    //The offset is in minutes -- convert it to ms
    return tmLoc.getTime() + tmLoc.getTimezoneOffset() * 60000;
}

Ensuite, ce dont vous avez généralement besoin est de formater la date / l'heure pour l'utilisateur final en fonction de son fuseau horaire et de son format locaux . Ce qui suit prend en charge toutes les complexités des formats de date et d'heure sur l'ordinateur client:

function formatDateTimeFromTicks(nTicks)
{
    //'nTicks' = number of milliseconds since midnight of January 1, 1970
    //RETURN:
    //      = Formatted date/time
    return new Date(nTicks).toLocaleString();
}

function formatDateFromTicks(nTicks)
{
    //'nTicks' = number of milliseconds since midnight of January 1, 1970
    //RETURN:
    //      = Formatted date
    return new Date(nTicks).toLocaleDateString();
}

function formatTimeFromTicks(nTicks)
{
    //'nTicks' = number of milliseconds since midnight of January 1, 1970
    //RETURN:
    //      = Formatted time
    return new Date(nTicks).toLocaleTimeString();
}

Donc l'exemple suivant:

var ticks = getCurrentTimeUTC();  //Or get it from the server

var __s = "ticks=" + ticks + 
    ", DateTime=" + formatDateTimeFromTicks(ticks) +
    ", Date=" + formatDateFromTicks(ticks) +
    ", Time=" + formatTimeFromTicks(ticks);

document.write("<span>" + __s + "</span>");

Renvoie ce qui suit (pour mes paramètres régionaux en anglais américain):

ticks = 1409103400661, DateHeure = 26/08/2014 6:36:40 PM, Date = 26/08/2014, Heure = 18:36:40 PM

Je pense que c'est une meilleure solution

// UTC milliseconds
new Date(Date.now()+(new Date().getTimezoneOffset()*60000)).getTime()

// UTC seconds
new Date(Date.now()+(new Date().getTimezoneOffset()*60000)).getTime()/1000|0

Si vous voulez un seule ligne , l' horodatage UTC Unix peut être créé en JavaScript comme:

var currentUnixTimestap = ~~(+new Date() / 1000);

Cela prendra en compte le fuseau horaire du système. C'est essentiellement le temps écoulé en secondes depuis l'époque.

Comment ça fonctionne:

• Créer un objet Date: new Date().
• Convertir en horodatage en ajoutant unary +avant la création de l'objet pour le convertir entimestamp integer . : +new Date().
• Convertissez des millisecondes en secondes: +new Date() / 1000
• Utilisez des doubles tildes pour arrondir la valeur à un entier. :~~(+new Date())

Je veux préciser que new Date (). GetTime () renvoie en fait une valeur UTC, c'est donc un moyen vraiment utile de stocker et de gérer les dates d'une manière indépendante des heures localisées.

En d'autres termes, ne vous embêtez pas avec toutes les fonctions javascript UTC. Au lieu de cela, utilisez simplement Date.getTime ().

Plus d'informations sur l'explication est ici: Si javascript "(new Date ()). GetTime ()" est exécuté à partir de 2 fuseaux horaires différents.

J'utilise ce qui suit:

Date.prototype.getUTCTime = function(){ 
  return this.getTime()-(this.getTimezoneOffset()*60000); 
};

Une fois définie cette méthode, vous pouvez faire:

var utcTime = new Date().getUTCTime();

Je suis étonné de voir à quel point cette question est devenue complexe.

Ce sont tous identiques, et leurs valeurs entières toutes === EPOCH time: D

console.log((new Date()).getTime() / 1000, new Date().valueOf() / 1000, (new Date() - new Date().getTimezoneOffset() * 60 * 1000) / 1000);

Ne me croyez pas, consultez: http://www.epochconverter.com/

Depuis new Date().toUTCString()renvoie une chaîne comme "Wed, 11 Oct 2017 09:24:41 GMT"vous pouvez découper les 3 derniers caractères et passer la chaîne découpée à new Date():

new Date()
// Wed Oct 11 2017 11:34:33 GMT+0200 (CEST)

new Date(new Date().toUTCString().slice(0, -3))
// Wed Oct 11 2017 09:34:33 GMT+0200 (CEST)

EDIT: Le code ci-dessous ne fonctionne PAS. J'ai toujours supposé que la nouvelle Date (). GetTime () renvoyait le nombre de secondes depuis le 1er janvier 1970 DANS LE FUSEAU HORAIRE ACTUEL. Ce n'est pas le cas: getTime () renvoie le nombre de secondes en UTC. Ainsi, le code ci-dessous fait un surajustement brut. Merci tout le monde!]

Tout d'abord, merci pour vos idées fantastiques. Je suppose que ma question n'avait pas le bon titre ... elle aurait dû être "Obtenir l'horodatage UTC Unix pour une date existante".

Donc, si j'ai un objet date:

var d = new Date(2009,01,31)

J'étais à la recherche d'une fonction qui me disait "L'horodatage UTC Unix".

Cette fonction semble être la vraie astuce:

Date.prototype.getUTCUnixTime =  function (){
  return Math.floor( new Date(
    this.getUTCFullYear(),
    this.getUTCMonth(),
    this.getUTCDate(),
    this.getUTCHours(),
    this.getUTCMinutes(), 
    this.getUTCSeconds()
  ).getTime() / 1000); 
}

Notez que cela fonctionne sur "ceci" Cela signifie que je peux faire:

var n = new Date(2008,10,10)
...
...

n.getUTCUnixTime();

Et obtenez le nombre de secondes depuis le 1er janvier 1970 à l'heure Unix. Droite?

C'est un peu fou, pour moi, que Javascript stocke tout à l'heure UTC, mais pour obtenir ce numéro, je dois créer un nouvel objet Date en passant les getters UTC individuels, puis enfin appeler getTime () pour cela ...

Merc.

Je pense que c'est ce à quoi vous vous attendez ...

var currTimestamp = Date.now(), //1482905176396
    utcDateString = (new Date(currTimestamp)).toUTCString(); //"Wed, 28 Dec 2016 06:06:50 GMT"

Maintenant,

new Date(utcDateString).getTime(); //This will give you UTC Timestamp in JavaScript

Une fois que vous faites cela

new Date(dateString).getTime() / 1000

C'est déjà l'horodatage UTC

   const getUnixTimeUtc = (dateString = new Date()) => Math.round(new Date(dateString).getTime() / 1000)

J'ai testé sur https://www.unixtimestamp.com/index.php

Utilisation de day.js

Dans le navigateur:

dayjs.extend(dayjs_plugin_utc)
console.log(dayjs.utc().unix())

<script src="https://cdn.jsdelivr.net/npm/dayjs@latest/dayjs.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/dayjs@latest/plugin/utc.js"></script>

Dans node.js:

import dayjs from 'dayjs'
dayjs.extend(require('dayjs/plugin/utc'))
console.log(dayjs.utc().unix())

Vous obtenez un horodatage UTC unix sans millisecondes.

Cela renverra l'horodatage en UTC:

var utc = new Date(new Date().toUTCString()).getTime();