Como você converte uma data JavaScript para UTC?

Suponha que um usuário do seu site insira um período.

2009-1-1 to 2009-1-3

Você precisa enviar esta data para um servidor para algum processamento, mas o servidor espera que todas as datas e horários estejam no UTC.

Agora, suponha que o usuário esteja no Alasca, Havaí ou Fiji. Como eles estão em um fuso horário bem diferente do UTC, o período precisa ser convertido para algo assim:

2009-1-1T8:00:00 to 2009-1-4T7:59:59

Usando o objeto Data JavaScript, como você converteria o primeiro período "localizado" em algo que o servidor entenderá?

O toISOString()método retorna uma sequência no formato ISO estendido simplificado ( ISO 8601 ), que sempre possui 24 ou 27 caracteres ( YYYY-MM-DDTHH:mm:ss.sssZou ±YYYYYY-MM-DDTHH:mm:ss.sssZ, respectivamente). O fuso horário é sempre o deslocamento UTC zero, conforme indicado pelo sufixo " Z".

Fonte: documentos da Web MDN

O formato que você precisa é criado com o .toISOString()método Para navegadores mais antigos (ie8 e inferiores), que não oferecem suporte nativo a esse método, o shim pode ser encontrado aqui :

Isso lhe dará a capacidade de fazer o que você precisa:

var isoDate = new Date('yourdatehere').toISOString();

Para o trabalho do fuso horário, o fuso horário moment.js e moment.js são ferramentas realmente inestimáveis ​​... especialmente para navegar nos fusos horários entre o javascript do cliente e o servidor.

Simples e estúpido

var date = new Date(); 
var now_utc =  Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(),
 date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds());

 return new Date(now_utc);

Aqui está o meu método:

var now = new Date();
var utc = new Date(now.getTime() + now.getTimezoneOffset() * 60000);

O utcobjeto resultante não é realmente uma data UTC, mas uma data local mudou para corresponder à hora UTC (ver comentários). No entanto, na prática, ele faz o trabalho.

Date.prototype.toUTCArray= function(){
    var D= this;
    return [D.getUTCFullYear(), D.getUTCMonth(), D.getUTCDate(), D.getUTCHours(),
    D.getUTCMinutes(), D.getUTCSeconds()];
}

Date.prototype.toISO= function(){
    var tem, A= this.toUTCArray(), i= 0;
    A[1]+= 1;
    while(i++<7){
        tem= A[i];
        if(tem<10) A[i]= '0'+tem;
    }
    return A.splice(0, 3).join('-')+'T'+A.join(':');    
}

Converta para ISO sem alterar a data / hora

var now = new Date(); // Fri Feb 20 2015 19:29:31 GMT+0530 (India Standard Time) 
var isoDate = new Date(now.getTime() - now.getTimezoneOffset() * 60000).toISOString();
//OUTPUT : 2015-02-20T19:29:31.238Z

Converta para ISO com alteração de data / hora (a data / hora será alterada)

isoDate = new Date(now).toISOString();
//OUTPUT : 2015-02-20T13:59:31.238Z 

Fiddle link

Os navegadores podem ser diferentes, e você também deve se lembrar de não confiar em nenhuma informação gerada pelo cliente; a declaração abaixo funciona para mim (Google Chrome v24 no Mac OS X 10.8.2)

var utcDate = new Date(new Date().getTime());

edit: "Como isso é diferente do que apenas new Date()?" veja aqui: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

• Se nenhum argumento for fornecido, o construtor criará um objeto Data do JavaScript para a data e hora atuais, de acordo com as configurações do sistema.
• Nota: Onde Date é chamado como um construtor com mais de um argumento, os argumentos especificados representam a hora local. Se UTC for desejado, use a nova Data ( Date.UTC (...) ) com os mesmos argumentos. (note: Date.UTC () retorna o número de milissegundos desde 1970-01-01 00:00:00 UTC)

A adição do 60000 * Date.getTimezoneOffset () como as respostas anteriores declararam está incorreta. Primeiro, você deve pensar em todas as datas / horas como já sendo UTC com um modificador de fuso horário para fins de exibição.

Mais uma vez, os navegadores podem diferir, no entanto, Date.getTime () retorna o número de milissegundos desde 01-01-2009 UTC / GMT. Se você criar uma nova Data usando esse número, como eu fiz acima, será UTC / GMT. No entanto, se você exibi-lo chamando .toString (), ele parecerá estar no fuso horário local porque .toString () usa o fuso horário local, não o fuso horário do objeto Date em que é chamado.

Também descobri que, se você chamar .getTimezoneOffset () em uma data, ele retornará seu fuso horário local, não o fuso horário do objeto de data em que você o chamou (no entanto, não posso verificar isso como padrão).

No meu navegador, adicionar 60000 * Date.getTimezoneOffset () cria um DateTime que não é UTC . No entanto, quando exibido no meu navegador (por exemplo: .toString ()), ele exibe um DateTime no meu fuso horário local que estaria no horário UTC correto se as informações do fuso horário forem ignoradas.

var myDate = new Date(); // Set this to your date in whichever timezone.
var utcDate = myDate.toUTCString();

Outra solução para converter para UTC e mantê-la como um objeto de data: (funciona removendo a parte 'GMT' do final da string formatada e colocando-a novamente no construtor Date)

var now = new Date();
var now_utc = new Date(now.toUTCString().slice(0, -4));

Eu precisava fazer isso para fazer interface com uma biblioteca de selecionador de data e hora. Mas, em geral, é uma má idéia trabalhar com datas dessa maneira.

Os usuários geralmente desejam trabalhar com data e hora no horário local; portanto, você atualiza o código do lado do servidor para analisar as seqüências de horas e horários com desvios corretamente e depois converte para UTC (melhor opção) ou para uma string UTC no lado do cliente antes de enviar para o servidor (como na resposta de Will Stern)

Você está tentando converter a data em uma string como essa?

Eu faria uma função para fazer isso e, embora seja um pouco controverso, adicione-o ao protótipo Date. Se você não estiver satisfeito com isso, poderá colocá-lo como uma função independente, passando a data como parâmetro.

Date.prototype.getISOString = function() {
    var zone = '', temp = -this.getTimezoneOffset() / 60 * 100;
    if (temp >= 0) zone += "+";
    zone += (Math.abs(temp) < 100 ? "00" : (Math.abs(temp) < 1000 ? "0" : "")) + temp;

    // "2009-6-4T14:7:32+10:00"
    return this.getFullYear()   // 2009
         + "-"
         + (this.getMonth() + 1) // 6
         + "-"
         + this.getDate()       // 4
         + "T"
         + this.getHours()      // 14
         + ":"
         + this.getMinutes()    // 7
         + ":"
         + this.getSeconds()    // 32
         + zone.substr(0, 3)    // +10
         + ":"
         + String(temp).substr(-2) // 00
    ;
};

Se você precisar no horário UTC, substitua todas as funções get * por getUTC *, por exemplo: getUTCFullYear, getUTCMonth, getUTCHours ... e depois adicione "+00: 00" no final, em vez do deslocamento do fuso horário do usuário.

date = '2012-07-28'; stringdate = new Date(date).toISOString();

deve funcionar na maioria dos navegadores mais recentes. retorna 2012-07-28T00:00:00.000Zno Firefox 6.0

Minha recomendação ao trabalhar com datas é analisar a data em campos individuais a partir da entrada do usuário. Você pode usá-lo como uma corda completa, mas está brincando com fogo.

O JavaScript pode tratar duas datas iguais em diferentes formatos de maneira diferente.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse

Nunca faça nada como:

new Date('date as text');

Depois de analisar sua data em seus campos individuais a partir da entrada do usuário, crie um objeto de data. Depois que o objeto de data é criado, converta-o para UTC adicionando o deslocamento do fuso horário. Não posso enfatizar a importância de usar o deslocamento do objeto de data devido ao horário de verão (no entanto, essa é outra discussão para mostrar o porquê).

var year = getFullYear('date as text');
var month = getMonth('date as text');
var dayOfMonth = getDate('date as text');

var date = new Date(year, month, dayOfMonth);

var offsetInMs = ((date.getTimezoneOffset() * 60)  // Seconds
                 * 1000);                          //  Milliseconds

var utcDate = new Date(date.getTime + offsetInMs);

Agora você pode passar a data para o servidor no horário UTC. Novamente, eu recomendo não usar nenhuma sequência de datas. Passe-o para o servidor dividido na menor granularidade necessária, por exemplo, ano, mês, dia, minuto ou como um valor em milissegundos da época do unix.

Se você lida muito com datas, vale a pena usar o moment.js ( http://momentjs.com ). O método para converter para UTC seria:

moment(yourTime).utc()

Você pode usar o formato para alterar sua data para qualquer formato que desejar:

moment(yourTime).utc().format("YYYY-MM-DD")

Também existem opções de deslocamento no momento, mas há uma biblioteca complementar adicional para lidar com o fuso horário ( http://momentjs.com/timezone/ ). A conversão de tempo seria tão simples como esta:

moment.tz(yourUTCTime, "America/New_York")

Minha solução mantém a data a mesma, independentemente do fuso horário definido no lado do cliente. Talvez alguém ache útil.

Meu caso de uso:

Estou criando um aplicativo de tarefas, onde você define a data da sua tarefa. Essa data deve permanecer constante, independentemente do fuso horário em que você estiver.

Exemplo. Você quer ligar para seu amigo às 8 da manhã de 25 de junho.

Você cria esta tarefa 5 dias antes (20 de junho) enquanto estiver na China.

Então, no mesmo dia, você voa para Nova York por alguns dias.

Então, em 25 de junho, enquanto você ainda está em Nova York, você acorda às 7:30 da manhã (o que significa que você deve receber uma notificação de tarefa em 30 minutos) tarefa)

Portanto, a tarefa está ignorando o fuso horário. Significa 'Eu quero fazer isso às 8 da manhã em qualquer fuso horário em que estarei'.

O que faço é dizer "presumo que você esteja sempre no fuso horário de Londres - UTC".

O que isso significa é - quando o usuário escolhe uma data em seu fuso horário - eu converto essa data para a mesma data no UTC. ie Você escolhe 8 da manhã na China, mas eu a converto para 8 da manhã no UTC.

Então - da próxima vez que você abrir o aplicativo - eu li a data salva no UTC e a converto para a mesma data no seu fuso horário atual - por exemplo. Eu converto 8 da manhã no UTC para 8 da manhã no fuso horário de Nova York.

Essa solução significa que a data pode significar outra coisa, dependendo de onde você está ao defini-la e de onde está lendo, mas permanece constante de uma maneira que parece que você está sempre no mesmo fuso horário.

Vamos escrever um código:

Primeiro - temos 2 funções principais para converter de / para UTC, ignorando o fuso horário:

export function convertLocalDateToUTCIgnoringTimezone(date: Date) {
  const timestamp = Date.UTC(
    date.getFullYear(),
    date.getMonth(),
    date.getDate(),
    date.getHours(),
    date.getMinutes(),
    date.getSeconds(),
    date.getMilliseconds(),
  );

  return new Date(timestamp);
}

export function convertUTCToLocalDateIgnoringTimezone(utcDate: Date) {
  return new Date(
    utcDate.getUTCFullYear(),
    utcDate.getUTCMonth(),
    utcDate.getUTCDate(),
    utcDate.getUTCHours(),
    utcDate.getUTCMinutes(),
    utcDate.getUTCSeconds(),
    utcDate.getUTCMilliseconds(),
  );
}

Em seguida, salvei / li esta data como:

function saveTaskDate(localDate: Date) {
  // I convert your local calendar date so it looks like you've picked it being in UTC somewhere around London
  const utcDate = convertLocalDateToUTCIgnoringTimezone(localDate);
  api.saveTaskDate(utcDate);
}

function readTaskDate(taskUtcDate: Date) {
  // I convert this UTC date to 'look in your local timezone' as if you were now in UTC somewhere around london
  const localDateWithSameDayAsUTC = convertUTCToLocalDateIgnoringTimezone(taskUtcDate);

  // this date will have the same calendar day as the one you've picked previously
  // no matter where you were saving it and where you are now
}

Acabei de descobrir que a versão 1.2.3 do date.format.js de Steven Levithan faz exatamente o que eu quero. Ele permite que você forneça uma string de formato para uma data JavaScript e converte da hora local para o UTC. Aqui está o código que estou usando agora:

// JavaScript dates don't like hyphens!    
var rectifiedDateText = dateText.replace(/-/g, "/");
var d = new Date(rectifiedDateText);

// Using a predefined mask from date.format.js.
var convertedDate = dateFormat(d, 'isoUtcDateTime'); 

Encontrei o jQuery Globalization Plugin data da análise do para funcionar melhor. Outros métodos tinham problemas entre navegadores e coisas como date.js não eram atualizadas há um bom tempo.

Você também não precisa de um datePicker na página. Você pode simplesmente chamar algo semelhante ao exemplo dado nos documentos:

$.parseDate('yy-mm-dd', '2007-01-26');

Esta função funciona muito bem para mim.

function ParseDateForSave(dateValue) {
    // create a new date object
    var newDate = new Date(parseInt(dateValue.substr(6)));

    // return the UTC version of the date
    return newDate.toISOString();
}

Usando o método UTC moment.js ;

const moment = require('moment');
const utc = moment.utc(new Date(string));

var userdate = new Date("2009-1-1T8:00:00Z");
var timezone = userdate.getTimezoneOffset();
var serverdate = new Date(userdate.setMinutes(userdate.getMinutes()+parseInt(timezone)));

Isso fornecerá a data e hora UTC apropriadas.
É porque getTimezoneOffset()isso lhe dará a diferença de fuso horário em minutos. Eu recomendo que você não use, toISOString()porque a saída estará na cadeia. Portanto, no futuro, você não poderá manipular a data

Isto é o que eu fiz no passado:

var utcDateString = new Date(new Date().toUTCString()).toISOString();

Se você precisar do objeto Data

Passar apenas a sequência de datas Date assume que a hora será 00:00 alterada pelo fuso horário:

new Date('2019-03-11')
Sun Mar 10 2019 18:00:00 GMT-0600 (Central Standard Time)

Se você adicionar horas e minutos atuais, obtém a data adequada:

new Date('2019-03-11 ' + new Date().getHours() + ':' + new Date().getMinutes())
Mon Mar 11 2019 04:36:00 GMT-0600 (Central Standard Time)

Observando a sua pergunta, fica claro que você deseja enviar o período ao seu back-end para posterior processamento posterior.

Suponho que você esteja em conformidade com as diretrizes de dados padrão que esperam que os dados estejam em um formato específico. Por exemplo, eu uso ODATA, que é uma API RESTfull que espera que os objetos de data e hora estejam no formato: -

AAAA-MM-DDT00: 00: 00.

Isso pode ser facilmente alcançado através do snippet publicado abaixo (altere o formato conforme sua exigência).

var mydate;//assuming this is my date object which I want to expose var UTCDateStr = mydate.getUTCFullYear() + "-" + mydate.getUTCMonth() + "-" + mydate.getUTCDate() + "T00:00:00";

Se, por outro lado, você estiver na minha situação em que você recebeu uma data do seu back-end e o navegador a converte na sua data local. Por outro lado, você está interessado na data UTC e pode executar o seguinte: -

var mydate;//assuming this is my date object which I want to expose var UTCDate = new Date(mydate);/*create a copy of your date object. Only needed if you for some reason need the original local date*/ UTCDate.setTime(UTCDate.getTime() + UTCDate.getTimezoneOffset() * 60 * 1000);

O trecho de código acima basicamente adiciona / subtrai o tempo adicionado / subtraído pelo navegador com base no fuso horário.

Por exemplo, se estou em EST (GMT-5) e meu Serviço retorna um objeto de data e hora = Wed Aug 17 2016 00:00:00 GMT-0500, meu navegador subtrai automaticamente o deslocamento do fuso horário (5 horas) para obter meu horário local. Portanto, se eu tentar obter o horário, recebo Wed 16 de agosto de 2016 19:00:00 GMT-0500. Isso causa muitos problemas. Existem muitas bibliotecas por aí que definitivamente tornarão isso mais fácil, mas eu queria compartilhar a abordagem JS pura.

Para obter mais informações, consulte: http://praveenlobo.com/blog/how-to-convert-javascript-local-date-to-utc-and-utc-to-local-date/ onde eu recebi meu inspiração.

Espero que isto ajude!

Este método fornecerá: 2017-08-04T11:15:00.000+04:30e você pode ignorar a variável de zona para simplesmente obter 2017-08-04T11:15:00.000.

function getLocalIsoDateTime(dtString) {
    if(dtString == "")
        return "";
    var offset = new Date().getTimezoneOffset();
    var localISOTime = (new Date(new Date(dtString) - offset * 60000 /*offset in milliseconds*/)).toISOString().slice(0,-1);
    //Next two lines can be removed if zone isn't needed.
    var absO = Math.abs(offset);
    var zone = (offset < 0 ? "+" : "-") + ("00" + Math.floor(absO / 60)).slice(-2) + ":" + ("00" + (absO % 60)).slice(-2);
    return localISOTime + zone;
}

Usando o pacote moment, você pode facilmente converter uma sequência de datas do UTC em um novo objeto Date:

const moment = require('moment');
let b = new Date(moment.utc('2014-02-20 00:00:00.000000'));
let utc = b.toUTCString();
b.getTime();

Isso ajuda especialmente quando o servidor não suporta fuso horário e você deseja armazenar a data UTC sempre no servidor e recuperá-la como um novo objeto Date. O código acima funcionou para o meu requisito de problema semelhante ao qual este segmento é. Compartilhando aqui para que possa ajudar os outros. Não vejo exatamente a solução acima em nenhuma resposta. Obrigado.

evento const = nova data ();

console.log (event.toUTCString ());

Eu sei que essa pergunta é antiga, mas estava analisando o mesmo problema, e uma opção seria enviar date.valueOf () para o servidor. a função valueOf () do javascript Date envia o número de milissegundos desde meia-noite de 1º de janeiro de 1970, UTC.

valor de()

Portanto, era dessa maneira que eu fazia isso porque eu ainda queria que um objeto de data JavaScript manipulasse como uma data e, infelizmente, muitas dessas respostas exigem que você vá para uma string.

//First i had a string called stringDateVar that i needed to convert to Date
var newDate = new Date(stringDateVar)

//output: 2019-01-07T04:00:00.000Z
//I needed it 2019-01-07T00:00:00.000Z because i had other logic that was dependent on that 

var correctDate = new Date(newDate.setUTCHours(0))

//This will output 2019-01-07T00:00:00.000Z on everything which allows scalability 

adicionar momento

import moment from 'moment';

//local Js date to UTC using moment
const utcDate = moment.utc(moment(new date()).format('YYYY-MM-DDTHH:mm:ss')).valueOf();
console.log('UTC Date', utcDate);


// UTC to local date without moment
const localDate = convertUTCDateToLocalDate(new Date(utcDate))
console.log('UTC Date', moment(localDate).format('MMM D, YYYY HH:mm'));


function convertUTCDateToLocalDate(date) {

   let newDate = new Date(date.getTime() + date.getTimezoneOffset()*60*1000);

   const offset = date.getTimezoneOffset() / 60;
   const hours = date.getHours();

   newDate.setHours(hours - offset);

   return newDate;

}

Ainda mais simples

myvar.setTime(myvar.getTime() + myvar.getTimezoneOffset() * 60000);