¿Cómo se convierte una fecha de JavaScript a UTC?

Supongamos que un usuario de su sitio web ingresa un rango de fechas.

2009-1-1 to 2009-1-3

Debe enviar esta fecha a un servidor para que se procese, pero el servidor espera que todas las fechas y horas estén en UTC.

Ahora suponga que el usuario se encuentra en Alaska o Hawai o Fiji. Como se encuentran en una zona horaria bastante diferente de UTC, el intervalo de fechas debe convertirse en algo como esto:

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

Con el objeto Fecha de JavaScript, ¿cómo convertiría el primer intervalo de fechas "localizado" en algo que el servidor comprenderá?

El toISOString()método devuelve una cadena en formato ISO extendido simplificado ( ISO 8601 ), que siempre tiene 24 o 27 caracteres de longitud ( YYYY-MM-DDTHH:mm:ss.sssZo ±YYYYYY-MM-DDTHH:mm:ss.sssZ, respectivamente). La zona horaria siempre es cero desplazamiento UTC, como se indica con el sufijo " Z".

Fuente: documentos web de MDN

El formato que necesita se crea con el .toISOString()método. Para navegadores más antiguos (es decir, 8 y menores), que no admiten este método de forma nativa, la cuña se puede encontrar aquí :

Esto le dará la capacidad de hacer lo que necesita:

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

Para el trabajo de Timezone , moment.js y moment.js timezone son herramientas realmente invaluables ... especialmente para navegar por zonas horarias entre el cliente y el servidor javascript.

Simple y estupido

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

Aquí está mi método:

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

El utcobjeto resultante no es realmente una fecha UTC, sino una fecha local desplazada para coincidir con la hora UTC (ver comentarios). Sin embargo, en la práctica hace el trabajo.

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

Convierte a ISO sin cambiar la fecha / 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

Convierte a ISO con un cambio en la fecha / hora (la fecha / hora cambiará)

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

Enlace de violín

Los navegadores pueden diferir, y también debe recordar no confiar en ninguna información generada por el cliente, dicho esto, la siguiente declaración me funciona (Google Chrome v24 en Mac OS X 10.8.2)

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

editar: "¿Cómo es esto diferente de solo new Date()?" ver aquí: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

• Si no se proporcionan argumentos, el constructor crea un objeto Fecha de JavaScript para la fecha y hora actuales de acuerdo con la configuración del sistema.
• Nota: Cuando se llama a Date como un constructor con más de un argumento, los argumentos especificados representan la hora local. Si se desea UTC, use la nueva Fecha ( Date.UTC (...) ) con los mismos argumentos. (nota: Date.UTC () devuelve el número de milisegundos desde 1970-01-01 00:00:00 UTC)

Agregar el 60000 * Date.getTimezoneOffset () como han dicho las respuestas anteriores es incorrecto. Primero, debe pensar que todas las fechas / horas ya son UTC con un modificador de zona horaria para fines de visualización.

Una vez más, los navegadores pueden diferir, sin embargo, Date.getTime () devuelve el número de milisegundos desde 1970-01-01 UTC / GMT. Si crea una nueva Fecha usando este número como lo hice anteriormente, será UTC / GMT. Sin embargo, si lo visualiza llamando a .toString (), parecerá estar en su zona horaria local porque .toString () usa su zona horaria local, no la zona horaria del objeto Date en el que se llama.

También descubrí que si llama a .getTimezoneOffset () en una fecha, le devolverá su zona horaria local, no la zona horaria del objeto de fecha en el que lo llamó (sin embargo, no puedo verificar que sea estándar).

En mi navegador, agregar 60000 * Date.getTimezoneOffset () crea un DateTime que no es UTC . Sin embargo, cuando se muestra en mi navegador (por ejemplo: .toString ()), muestra una fecha y hora en mi zona horaria local que sería la hora UTC correcta si se ignora la información de la zona horaria.

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

Otra solución para convertir a UTC y mantenerlo como un objeto de fecha: (Funciona eliminando la parte 'GMT' del final de la cadena formateada y luego volviéndola a colocar en el constructor de Fecha)

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

Necesitaba hacer esto para interactuar con una biblioteca de selector de fecha y hora. Pero en general es una mala idea trabajar con fechas de esta manera.

Los usuarios generalmente desean trabajar con fechas y horas en su hora local, por lo que puede actualizar el código del lado del servidor para analizar las cadenas de fecha y hora con las compensaciones correctamente, luego convertir a UTC (la mejor opción) o convertir a una cadena UTC del lado del cliente antes de enviar al servidor (como en la respuesta de Will Stern)

¿Estás tratando de convertir la fecha en una cadena como esa?

Haría una función para hacer eso y, aunque es un poco controvertido, lo agregaría al prototipo de Date. Si no se siente cómodo con eso, puede ponerlo como una función independiente, pasando la fecha 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
    ;
};

Si lo necesitaba en tiempo UTC, simplemente reemplace todas las funciones get * con getUTC *, por ejemplo: getUTCFullYear, getUTCMonth, getUTCHours ... y luego simplemente agregue "+00: 00" al final en lugar del desplazamiento de la zona horaria del usuario.

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

Debería funcionar en la mayoría de los navegadores más nuevos. vuelve 2012-07-28T00:00:00.000Zen Firefox 6.0

Mi recomendación al trabajar con fechas es analizar la fecha en campos individuales a partir de la entrada del usuario. Puedes usarlo como una cadena completa, pero estás jugando con fuego.

JavaScript puede tratar dos fechas iguales en diferentes formatos de manera diferente.

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

Nunca hagas nada como:

new Date('date as text');

Una vez que haya analizado su fecha en sus campos individuales a partir de la entrada del usuario, cree un objeto de fecha. Una vez que se crea el objeto de fecha, conviértalo a UTC agregando el desplazamiento de zona horaria. No puedo enfatizar lo importante que es usar el desplazamiento desde el objeto de fecha debido a DST (sin embargo, esa es otra discusión para mostrar por qué).

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

Ahora puede pasar la fecha al servidor en hora UTC. Nuevamente, recomendaría no usar cadenas de fecha. Páselo al servidor desglosado a la granularidad más baja que necesite, por ejemplo, año, mes, día, minuto o como un valor como milisegundos de la época de Unix.

Si tiene muchas citas, vale la pena usar moment.js ( http://momentjs.com ). El método para convertir a UTC sería:

moment(yourTime).utc()

Puede usar el formato para cambiar su fecha a cualquier formato que desee:

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

También hay opciones de compensación en este momento, pero hay una biblioteca complementaria adicional para tratar con la zona horaria ( http://momentjs.com/timezone/ ). La conversión de tiempo sería tan simple como esta:

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

Mi solución mantiene la fecha igual sin importar la zona horaria establecida en el lado del cliente. Quizás alguien lo encuentre útil.

Mi caso de uso:

Estoy creando una aplicación de tareas, donde estableces la fecha de tu tarea. Esta fecha debe permanecer constante sin importar en qué zona horaria se encuentre.

Ejemplo. Desea llamar a su amigo a las 8 am el 25 de junio.

Crea esta tarea 5 días antes (20 de junio) mientras estás en China.

Luego, el mismo día, vuelas a Nueva York por unos días.

Luego, el 25 de junio, mientras todavía está en Nueva York, se despierta a las 7:30 a.m. (lo que significa que debe recibir una notificación de la tarea en 30 minutos (aunque sea la 1:30 p.m., ya en China, donde estaba cuando creó el tarea)

Entonces la tarea es ignorar la zona horaria. Significa 'Quiero hacerlo a las 8 a.m. en cualquier zona horaria en la que esté'.

Lo que hago es decir 'supongo que siempre estás en la zona horaria de Londres - UTC'.

Lo que significa es que, cuando el usuario elige alguna fecha en su zona horaria, convierto esta fecha en la misma fecha en UTC. es decir. Eliges las 8 am en China, pero lo convierto a las 8 am en UTC.

Luego, la próxima vez que abra la aplicación, leo la fecha guardada en UTC y la convierto a la misma fecha en su zona horaria actual, por ejemplo. Convierto las 8 am en UTC a las 8 am en la zona horaria de Nueva York.

Esta solución significa que la fecha puede significar algo más dependiendo de dónde se encuentre al configurarla y dónde la esté leyendo, pero permanece constante de una manera que 'se siente' como si siempre estuviera en la misma zona horaria.

Escribamos un código:

Primero, tenemos 2 funciones principales para convertir de / a UTC ignorando la zona horaria:

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

Luego, guardo / leo esta fecha 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
}

Acabo de descubrir que la versión 1.2.3 de date.format.js de Steven Levithan hace exactamente lo que quiero. Le permite proporcionar una cadena de formato para una fecha de JavaScript y se convertirá desde la hora local a UTC. Aquí está el código que estoy usando ahora:

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

He encontrado que el análisis de fechas de jQuery Globalization Plugin funciona mejor. Otros métodos tenían problemas de navegador cruzado y cosas como date.js no se habían actualizado en mucho tiempo.

Tampoco necesita un selector de fecha en la página. Simplemente puede llamar a algo similar al ejemplo dado en los documentos:

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

Esta función funciona muy bien para mí.

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 el método moment.js UTC ;

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

Esto le dará la fecha y hora UTC adecuadas.
Es porque getTimezoneOffset()le dará la diferencia de zona horaria en minutos. Te recomiendo que no uses toISOString()porque la salida estará en la cadena. Por lo tanto, en el futuro no podrás manipular la fecha

Esto es lo que he hecho en el pasado:

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

Si necesita Fecha Objeto

Al pasar solo la cadena de fecha, la fecha asume que la hora se 00:00 desplazada por zona horaria:

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

Si agrega las horas y minutos actuales, obtiene la fecha adecuada:

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

Al analizar su pregunta, está claro que solo desea enviar el rango de fechas a su back-end para su posterior procesamiento posterior.

Supongo que cumple con las pautas de datos estándar que esperan que los datos estén en un formato particular. Por ejemplo, uso ODATA, que es una API RESTfull que espera que los objetos de fecha y hora tengan el formato:

AAAA-MM-DDT00: 00: 00.

Eso se puede lograr fácilmente a través del fragmento publicado a continuación (cambie el formato según sus requisitos).

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

Si, por otro lado, se encuentra en mi situación en la que recibió una fecha de su servidor y el navegador la convierte a su fecha local. Por otro lado, usted está interesado en la fecha UTC, luego puede realizar lo siguiente:

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

El fragmento de código anterior básicamente agrega / resta el tiempo agregado / restado por el navegador en función de la zona horaria.

Por ejemplo, si estoy en EST (GMT-5) y mi servicio devuelve un objeto de fecha y hora = mié 17 de agosto de 2016 00:00:00 GMT-0500, mi navegador resta automáticamente el desplazamiento de la zona horaria (5 horas) para obtener mi hora local. Entonces, si trato de recuperar el tiempo, recibo el miércoles 16 de agosto de 2016 19:00:00 GMT-0500. Esto causa muchos problemas. Hay muchas bibliotecas que definitivamente lo harán más fácil, pero quería compartir el enfoque JS puro.

Para obtener más información, consulte: http://praveenlobo.com/blog/how-to-convert-javascript-local-date-to-utc-and-utc-to-local-date/ donde obtuve mi inspiración.

¡Espero que esto ayude!

Este método le dará: 2017-08-04T11:15:00.000+04:30y puede ignorar la variable de zona para obtener simplemente 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;
}

Con el paquete de momento, puede convertir fácilmente una cadena de fecha de UTC en un nuevo objeto Fecha:

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

Esto ayuda especialmente cuando su servidor no admite la zona horaria y desea almacenar la fecha UTC siempre en el servidor y recuperarla como un nuevo objeto Date. El código anterior funcionó para mi requisito de problema similar para el que es este hilo. Compartir aquí para que pueda ayudar a otros. No veo exactamente la solución anterior en ninguna respuesta. Gracias.

evento const = nueva fecha ();

console.log (event.toUTCString ());

Sé que esta pregunta es antigua, pero estaba viendo este mismo problema, y ​​una opción sería enviar date.valueOf () al servidor en su lugar. La función valueOf () de la fecha javascript envía el número de milisegundos desde la medianoche del 1 de enero de 1970 UTC.

valor de()

Así que esta era la forma en que tenía que hacerlo porque todavía quería un objeto de fecha JavaScript para manipular como fecha y desafortunadamente muchas de estas respuestas requieren que vaya a una cadena.

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

hilo agregar 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;

}

Aún más simple

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