Ao escrever um aplicativo Web, faz sentido armazenar (lado do servidor) todas as datas no DB como registros de data e hora UTC.

Fiquei surpreso quando percebi que você não podia fazer muito nativamente em termos de manipulação de fuso horário no JavaScript.

Estendi um pouco o objeto Date. Essa função faz sentido? Basicamente, toda vez que eu enviar algo para o servidor, será um carimbo de data / hora formatado com esta função ...

Você vê algum problema grave aqui? Ou talvez uma solução de um ângulo diferente?

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

Parece um pouco complicado para mim. E também não tenho tanta certeza sobre o desempenho.

1. As datas construídas dessa maneira usam o fuso horário local, tornando a data de construção incorreta. Definir o fuso horário de um determinado objeto de data é construí-lo a partir de uma sequência de datas que inclua o fuso horário. (Eu tive problemas para que isso funcionasse em um navegador Android mais antigo.)

2. Observe que getTime()retorna milissegundos, não segundos simples.

Para um carimbo de data / hora UTC / Unix, o seguinte deve ser suficiente:

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

Ele fatorará o fuso horário atual compensado no resultado. Para uma representação em cadeia, a resposta de David Ellis funciona.

Esclarecer:

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

Essa entrada é tratada como hora local . Se a hora UTC for passada, os resultados serão diferentes. Observe (eu estou no GMT +02: 00 agora, e são 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

Observe também que getUTCDate()não pode ser substituído getUTCDay(). Isso ocorre porque getUTCDate()retorna o dia do mês ; enquanto que, getUTCDay()retorna o dia da semana .

Você também pode fazer isso utilizando getTimezoneOffset e getTime,

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

console.log("UTCseconds", UTCseconds)

A maneira mais fácil de obter a hora UTC em um formato convencional é a seguinte:

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

Na verdade, acho que os valores de data em js são muito melhores do que os objetos C # DateTime. Os objetos C # DateTime possuem uma propriedade Kind, mas nenhum fuso horário subjacente estrito como tal e as conversões de fuso horário são difíceis de rastrear se você estiver convertendo entre dois horários não UTC e não locais. Em js, todos os valores de Data têm um valor UTC subjacente, que é transmitido e conhecido, independentemente das conversões ofensivas ou de fuso horário que você faz. Minha maior reclamação sobre o objeto Date é a quantidade de comportamento indefinido que os implementadores de navegador escolheram incluir, o que pode confundir as pessoas que atacam datas em js com tentativa e erro do que ler as especificações. Usar algo como iso8601.js resolve esse comportamento variável, definindo uma única implementação do objeto Date.

Por padrão, a especificação diz que você pode criar datas com um formato de data ISO 8601 estendido, como

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

Assim, você pode deduzir a hora exata do UTC dessa maneira.

Quando você deseja passar o valor Date de volta para o servidor, você chamaria

someDate.toISOString();

ou se você preferir trabalhar com um registro de data e hora em milissegundos (número de milissegundos a partir do 1º de janeiro de 1970 UTC)

someDate.getTime();

ISO 8601 é um padrão. Você não pode ficar confuso sobre o que significa uma sequência de datas se incluir o deslocamento da data. O que isso significa para você como desenvolvedor é que você nunca precisa lidar com as conversões da hora local . Os valores da hora local existem exclusivamente para o benefício do usuário, e os valores da data, por padrão, são exibidos na hora local. Todas as manipulações de horário local permitem exibir algo sensível ao usuário e converter seqüências de caracteres da entrada do usuário. É uma boa prática converter para UTC o mais rápido possível, e o objeto js Date torna isso bastante trivial.

Por outro lado, não há muito escopo para forçar o fuso horário ou a região para o cliente (que eu conheço), o que pode ser irritante para configurações específicas do site, mas acho que o motivo por trás disso é que é um usuário configuração que não deve ser tocada.

Portanto, em resumo, a razão pela qual não há muito suporte nativo para manipulação de fuso horário é porque você simplesmente não deseja fazê-lo.

Geralmente, você não precisa fazer muita "manipulação de fuso horário" no lado do cliente. Como regra, tento armazenar e trabalhar com datas UTC, na forma de ticks" número de milissegundos desde meia-noite de 1º de janeiro de 1970 ". Isso realmente simplifica o armazenamento, a classificação, o cálculo de compensações e, acima de tudo, livra você da dor de cabeça dos ajustes "Horário de verão". Aqui está um pequeno código JavaScript que eu uso.

Para obter a hora UTC atual:

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

Em geral, o que você precisa é formatar a data / hora do usuário final para o fuso horário local e o formato. A seguir, cuida de todas as complexidades dos formatos de data e hora no computador cliente:

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

Então, o seguinte exemplo:

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

Retorna o seguinte (para minha localidade em inglês dos EUA):

ticks = 1409103400661, DateTime = 26/08/2014 18:36:40, Data = 26/08/2014, Hora = 18: 36: 40 PM

Eu acho que essa é uma solução melhor

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

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

Se você deseja um liner , o Registro de data e hora UTC Unix pode ser criado em JavaScript como:

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

Isso levará em consideração o fuso horário do sistema. É basicamente o tempo decorrido em segundos desde a época.

Como funciona:

• Criar objeto de data: new Date().
• Converta em timestamp adicionando unary +antes da criação do objeto para convertê-lo timestamp integer. : +new Date().
• Converta milissegundos em segundos: +new Date() / 1000
• Use tildes duplos para arredondar o valor para número inteiro. :~~(+new Date())

Quero deixar claro que o novo Date (). GetTime () realmente retorna um valor UTC, portanto, é uma maneira realmente útil de armazenar e gerenciar datas de uma maneira que seja independente dos horários localizados.

Em outras palavras, não se preocupe com todas as funções javascript do UTC. Em vez disso, basta usar Date.getTime ().

Mais informações sobre a explicação estão aqui: Se o javascript "(nova Data ()). GetTime ()" for executado em 2 fusos horários diferentes.

Eu uso o seguinte:

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

Depois de definido esse método, você pode fazer:

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

Estou impressionado com a complexidade dessa questão.

Todos são idênticos e todos os seus valores inteiros === EPOCH time: D

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

Não acredite em mim, checkout: http://www.epochconverter.com/

Como new Date().toUTCString()retorna uma sequência como "Wed, 11 Oct 2017 09:24:41 GMT"você pode cortar os três últimos caracteres e passar a sequência fatiada para 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: O código abaixo NÃO funciona. Eu estava sempre assumindo que o novo Date (). GetTime () retornou o número de segundos desde o 1º de janeiro de 1970 NO FUSO FUSO ATUAL. Este não é o caso: getTime () retorna o número de segundos no UTC. Portanto, o código abaixo faz um superajuste bruto. Obrigado a todos!]

Primeiro de tudo, obrigado por suas ideias fantásticas. Eu acho que minha pergunta tinha o título errado ... deveria ter sido "Obtenha o carimbo de data / hora UTC Unix para uma data existente".

Então, se eu tiver um objeto de data:

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

Eu estava atrás de uma função que me dizia "The UTC Unix Timestamp".

Esta função parece ser o verdadeiro truque:

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

Observe que funciona em "this" Isso significa que eu posso fazer:

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

n.getUTCUnixTime();

E obtenha o número de segundos desde 1º de janeiro de 1970 no horário Unix. Certo?

É um pouco insano, para mim, que o Javascript armazene tudo em horários UTC, mas para obter esse número, tenho que criar um novo objeto Date passando os getters UTC individuais e, finalmente, chamar getTime () para isso ...

Merc.

Eu acho que é isso que você está esperando ...

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

Agora,

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

Depois de fazer isso

new Date(dateString).getTime() / 1000

Já é hora UTC

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

Eu testei em https://www.unixtimestamp.com/index.php

Usando day.js

No navegador:

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>

No node.js:

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

Você recebe um registro de data e hora UTC unix sem milissegundos.

Isso retornará o registro de data e hora no UTC:

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