Come si converte una data JavaScript in UTC?

Supponiamo che un utente del tuo sito Web inserisca un intervallo di date.

2009-1-1 to 2009-1-3

È necessario inviare questa data a un server per l'elaborazione, ma il server prevede che tutte le date e gli orari siano in UTC.

Supponiamo ora che l'utente sia in Alaska, alle Hawaii o alle Figi. Poiché si trovano in un fuso orario piuttosto diverso da UTC, l'intervallo di date deve essere convertito in qualcosa del genere:

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

Utilizzando l'oggetto JavaScript Date, come converti il ​​primo intervallo di date "localizzato" in qualcosa che il server capirà?

Il toISOString()metodo restituisce una stringa in formato ISO esteso semplificato ( ISO 8601 ), che è sempre lunga 24 o 27 caratteri ( YYYY-MM-DDTHH:mm:ss.sssZo ±YYYYYY-MM-DDTHH:mm:ss.sssZ, rispettivamente). Il fuso orario è sempre zero UTC offset, come indicato dal suffisso " Z".

Fonte: documenti web MDN

Il formato necessario è creato con il .toISOString()metodo Per i browser meno recenti (ie8 e precedenti), che non supportano nativamente questo metodo, lo shim può essere trovato qui :

Questo ti darà la possibilità di fare ciò di cui hai bisogno:

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

Per il fuso orario , time.js e moment.js sono strumenti davvero preziosi ... soprattutto per la navigazione dei fusi orari tra javascript client e server.

Semplice e stupido

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

Ecco il mio metodo:

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

L' utcoggetto risultante non è in realtà una data UTC, ma una data locale è stata spostata per corrispondere all'ora UTC (vedere i commenti). Tuttavia, in pratica fa il lavoro.

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

Converti in ISO senza cambiare data / ora

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

Converti in ISO con modifica di data / ora (la data / ora verrà modificata)

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

Collegamento a violino

I browser possono differire e dovresti anche ricordare di non fidarti delle informazioni generate dal client, detto ciò, la seguente dichiarazione funziona per me (Google Chrome v24 su Mac OS X 10.8.2)

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

modifica: "In che modo è diverso da solo new Date()?" vedi qui: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

• Se non viene fornito alcun argomento, il costruttore crea un oggetto Date JavaScript per la data e l'ora correnti in base alle impostazioni di sistema.
• Nota: dove Date viene chiamato come costruttore con più di un argomento, gli argomenti specificati rappresentano l'ora locale. Se si desidera UTC, utilizzare la nuova data ( Date.UTC (...) ) con gli stessi argomenti. (nota: Date.UTC () restituisce il numero di millisecondi dal 1970-01-01 00:00:00 UTC)

L'aggiunta di 60000 * Date.getTimezoneOffset () come indicato nelle risposte precedenti non è corretta. Innanzitutto, devi considerare tutte le date / ore come già UTC con un modificatore del fuso orario per scopi di visualizzazione.

Ancora una volta, i browser possono differire, tuttavia, Date.getTime () restituisce il numero di millisecondi dal 1970-01-01 UTC / GMT. Se crei una nuova data usando questo numero come faccio sopra, sarà UTC / GMT. Tuttavia, se lo visualizzi chiamando .toString () apparirà nel tuo fuso orario locale perché .toString () usa il tuo fuso orario locale, non il fuso orario dell'oggetto Date su cui viene chiamato.

Ho anche scoperto che se chiami .getTimezoneOffset () in una data, restituirà il tuo fuso orario locale, non il fuso orario dell'oggetto data su cui lo hai chiamato (non posso verificare che questo sia standard).

Nel mio browser, l'aggiunta di 60000 * Date.getTimezoneOffset () crea un DateTime che non è UTC . Tuttavia, quando visualizzato nel mio browser (ad es. .ToString ()), visualizza un DateTime nel mio fuso orario locale che sarebbe l'ora UTC corretta se le informazioni sul fuso orario fossero ignorate.

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

Un'altra soluzione per convertire in UTC e mantenerlo come oggetto data: (Funziona rimuovendo la parte 'GMT' dalla fine della stringa formattata, quindi reinserendola nel costruttore della data)

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

Ho dovuto farlo per interfacciarmi con una libreria di selezione datetime. Ma in generale è una cattiva idea lavorare con le date in questo modo.

Gli utenti in genere desiderano lavorare con i tempi dei dati nella loro ora locale, quindi aggiorni il codice lato server per analizzare correttamente le stringhe datetime con offset, quindi converti in UTC (opzione migliore) o converti in una stringa UTC lato client prima di inviarlo al server (come nella risposta di Will Stern)

Stai cercando di convertire la data in una stringa del genere?

Farei una funzione per farlo e, sebbene sia leggermente controverso, lo aggiungerei al prototipo di Date. Se non ti senti a tuo agio nel farlo, puoi metterlo come funzione autonoma, passando la data come parametro.

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 ne avevi bisogno in tempo UTC, sostituisci tutte le funzioni get * con getUTC *, ad esempio: getUTCFullYear, getUTCMonth, getUTCHours ... e quindi aggiungi "+00: 00" alla fine invece dell'offset del fuso orario dell'utente.

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

dovrebbe funzionare nella maggior parte dei browser più recenti. ritorna 2012-07-28T00:00:00.000Zsu Firefox 6.0

La mia raccomandazione quando si lavora con le date è di analizzare la data in singoli campi dall'input dell'utente. Puoi usarlo come una stringa completa, ma stai giocando con il fuoco.

JavaScript può trattare due date uguali in diversi formati in modo diverso.

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

Non fare mai niente del genere:

new Date('date as text');

Dopo aver analizzato la tua data nei suoi singoli campi dall'input dell'utente, crea un oggetto data. Una volta creato l'oggetto data, convertilo in UTC aggiungendo l'offset del fuso orario. Non posso sottolineare quanto sia importante utilizzare l'offset dall'oggetto data a causa dell'ora legale (questa è un'altra discussione per mostrare il perché).

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

Ora puoi passare la data al server in ora UTC. Ancora una volta, consiglio vivamente di non utilizzare stringhe di date. Passalo al server suddiviso per la minima granularità di cui hai bisogno, ad esempio anno, mese, giorno, minuto o come valore in millisecondi dall'epoca unix.

Se hai molto a che fare con le date, vale la pena usare moment.js ( http://momentjs.com ). Il metodo per convertire in UTC sarebbe:

moment(yourTime).utc()

Puoi utilizzare il formato per modificare la data in qualsiasi formato desiderato:

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

Ci sono anche opzioni di offset al momento, ma c'è una libreria aggiuntiva aggiuntiva per gestire il fuso orario ( http://momentjs.com/timezone/ ). La conversione del tempo sarebbe semplice come questa:

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

La mia soluzione mantiene la data uguale indipendentemente dal fuso orario impostato sul lato client. Forse qualcuno lo troverà utile.

Il mio caso d'uso:

Sto creando un'app todo, in cui hai impostato la data della tua attività. Questa data dovrebbe rimanere costante, indipendentemente dal fuso orario in cui ti trovi.

Esempio. Vuoi chiamare il tuo amico alle 8 del mattino del 25 giugno.

Questa attività viene creata 5 giorni prima (20 giugno) mentre si è in Cina.

Quindi, lo stesso giorno, voli a New York per alcuni giorni.

Quindi, il 25 giugno, mentre sei ancora a New York, ti ​​svegli alle 7:30 (il che significa che dovresti ricevere la notifica dell'attività in 30 minuti (anche se sono le 13:30 già in Cina dove eri quando hai creato il compito)

Quindi l'attività ignora il fuso orario. Significa "Voglio farlo alle 8 del mattino in qualunque fuso orario sarò".

Quello che faccio è dire "Suppongo che tu sia sempre nel fuso orario di Londra - UTC".

Ciò significa che - quando l'utente sceglie una data nel suo fuso orario - converto questa data nella stessa data in UTC. vale a dire. Scegli le 8 del mattino in Cina, ma le converto alle 8 del mattino in UTC.

Quindi - la prossima volta che apri l'app - ho letto la data salvata in UTC e la converto nella stessa data nel tuo fuso orario corrente - ad es. Converto le 8:00 in UTC alle 8:00 nel fuso orario di New York.

Questa soluzione significa che la data può significare qualcos'altro a seconda di dove ti trovi quando la imposti e dove la stai leggendo, ma rimane costante in un modo in cui "ti senti" come se fossi sempre nello stesso fuso orario.

Scriviamo un po 'di codice:

Primo: abbiamo 2 funzioni principali per la conversione da / in UTC ignorando il fuso orario:

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

Quindi, salvo / leggo questa data come:

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
}

Ho appena scoperto che la versione 1.2.3 di date.format.js di Steven Levithan fa esattamente quello che voglio. Ti consente di fornire una stringa di formato per una data JavaScript e convertirà da ora locale a UTC. Ecco il codice che sto usando ora:

// 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'); 

Ho trovato che la data del plug-in di globalizzazione jQuery funziona meglio. Altri metodi avevano problemi tra browser e cose come date.js non erano state aggiornate da un po 'di tempo.

Inoltre, non è necessario un DatePicker nella pagina. Puoi semplicemente chiamare qualcosa di simile all'esempio fornito nei documenti:

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

Questa funzione funziona magnificamente per me.

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

Utilizzando il metodo 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)));

Questo ti darà la data e l'ora UTC corrette.
È perché getTimezoneOffset()ti darà la differenza di fuso orario in minuti. Ti consiglio di non usarlo toISOString()perché l'output sarà nella stringa Quindi in futuro non sarai in grado di manipolare la data

Questo è quello che ho fatto in passato:

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

Se hai bisogno di un oggetto data

Passaggio solo della stringa della data La data presuppone che l'ora venga spostata in base alle 00:00 in base al fuso orario:

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

Se aggiungi le ore e i minuti correnti ottieni la data corretta:

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

Osservando la tua domanda è chiaro che vuoi solo inviare l'intervallo di date al tuo back-end per un'ulteriore elaborazione post.

Presumo che tu sia conforme alle linee guida standard sui dati che prevedono che i dati siano in un formato particolare. Ad esempio, utilizzo ODATA che è un'API RESTfull che prevede che gli oggetti data e ora siano nel formato: -

AAAA-MM-DDT00: 00: 00.

Ciò può essere facilmente ottenuto tramite lo snippet pubblicato di seguito (si prega di cambiare il formato secondo le proprie esigenze).

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 d'altra parte, ti trovi nella mia situazione in cui hai ricevuto una data dal tuo back-end e il browser la converte nella tua data locale. D'altra parte sei interessato alla data UTC, quindi puoi eseguire le seguenti operazioni: -

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

Lo snippet di codice sopra in sostanza aggiunge / sottrae il tempo aggiunto / sottratto dal browser in base al fuso orario.

Ad esempio, se sono in EST (GMT-5) e il mio servizio restituisce un oggetto data / ora = mer 17 ago 2016 00:00:00 GMT-0500 il mio browser sottrae automaticamente la differenza di fuso orario (5 ore) per ottenere l'ora locale. Quindi, se provo a recuperare il tempo che ottengo mer 16 agosto 2016 19:00:00 GMT-0500. Ciò causa molti problemi. Ci sono molte librerie là fuori che renderanno sicuramente più facile questo, ma volevo condividere il puro approccio JS.

Per maggiori informazioni, consultare: http://praveenlobo.com/blog/how-to-convert-javascript-local-date-to-utc-and-utc-to-local-date/ dove in ho ottenuto il mio ispirazione.

Spero che sia di aiuto!

Questo metodo ti darà: 2017-08-04T11:15:00.000+04:30e puoi ignorare la variabile di zona per ottenere semplicemente 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;
}

Utilizzando il pacchetto moment, puoi facilmente convertire una stringa di data di UTC in un nuovo oggetto Date:

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

Ciò è particolarmente utile quando il server non supporta il fuso orario e si desidera memorizzare la data UTC sempre nel server e ripristinarla come nuovo oggetto Date. Il codice sopra ha funzionato per il mio requisito di problema simile per questo thread. Condividere qui in modo che possa aiutare gli altri. Non vedo esattamente sopra la soluzione in nessuna risposta. Grazie.

const event = new Date ();

console.log (event.toUTCString ());

So che questa domanda è vecchia, ma stava esaminando lo stesso problema e un'opzione sarebbe invece di inviare date.valueOf () al server. la funzione valueOf () della data javascript invia il numero di millisecondi dalla mezzanotte del 1 gennaio 1970 UTC.

valore di()

Quindi questo è il modo in cui ho dovuto farlo perché volevo ancora un oggetto data JavaScript da manipolare come data e sfortunatamente molte di queste risposte richiedono che tu vada a una stringa.

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

il filato aggiunge un 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;

}

Ancora più semplice

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