Как конвертировать дату JavaScript в UTC?

Предположим, что пользователь вашего сайта вводит диапазон дат.

2009-1-1 to 2009-1-3

Вам необходимо отправить эту дату на сервер для некоторой обработки, но сервер ожидает, что все даты и время будут в UTC.

Теперь предположим, что пользователь находится на Аляске, Гавайях или Фиджи. Так как они находятся в часовом поясе, весьма отличном от UTC, диапазон дат необходимо преобразовать во что-то вроде этого:

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

Используя объект Date в JavaScript, как бы вы преобразовали первый «локализованный» диапазон дат в то, что сервер поймет?

toISOString()Метод возвращает строку , в упрощенном расширенном формате ISO ( ISO 8601 ), который всегда 24 или 27 символов длиной ( YYYY-MM-DDTHH:mm:ss.sssZили ±YYYYYY-MM-DDTHH:mm:ss.sssZ, соответственно). Часовой пояс всегда равен нулевому смещению UTC, что обозначается суффиксом " Z".

Источник: MDN веб-документы

Необходимый формат создается .toISOString()методом. Для более старых браузеров (т.е. 8 и ниже), которые изначально не поддерживают этот метод, шим можно найти здесь :

Это даст вам возможность делать то, что вам нужно:

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

Для работы с часовым поясом , zone.js и moment.js являются действительно бесценными инструментами ... особенно для навигации по часовым поясам между клиентом и сервером javascript.

Просто и глупо

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

Вот мой метод:

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

Результирующий utcобъект на самом деле не является датой UTC, но локальная дата смещена в соответствии с временем UTC (см. Комментарии). Однако на практике это делает работу.

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

Конвертировать в ISO без изменения даты / времени

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

Конвертировать в ISO с изменением даты / времени (дата / время будут изменены)

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

Скриптовая ссылка

Браузеры могут отличаться, и вы также должны помнить, что не следует доверять какой-либо информации, сгенерированной клиентом, поскольку, как говорится, нижеприведенное утверждение работает для меня (Google Chrome v24 на Mac OS X 10.8.2)

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

Редактировать: "Как это отличается от всего new Date()?" смотрите здесь: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

• Если аргументы не предоставлены, конструктор создает объект JavaScript Date для текущей даты и времени в соответствии с настройками системы.
• Примечание. Если Date вызывается как конструктор с более чем одним аргументом, указанные аргументы представляют собой местное время. Если требуется UTC, используйте новую дату ( Date.UTC (...) ) с теми же аргументами. (примечание: Date.UTC () возвращает количество миллисекунд с 1970-01-01 00:00:00 UTC)

Добавление 60000 * Date.getTimezoneOffset (), как указано в предыдущих ответах, неверно. Во-первых, вы должны думать обо всех датах / временах как о времени UTC с модификатором часового пояса для целей отображения.

Опять же, браузеры могут отличаться, однако Date.getTime () возвращает количество миллисекунд с 1970-01-01 UTC / GMT. Если вы создадите новую дату, используя этот номер, как я делаю выше, это будет UTC / GMT. Однако, если вы отобразите его, вызвав .toString (), он окажется в вашем местном часовом поясе, потому что .toString () использует ваш местный часовой пояс, а не часовой пояс объекта Date, для которого он вызывается.

Я также обнаружил, что если вы вызываете .getTimezoneOffset () для даты, она вернет ваш местный часовой пояс, а не часовой пояс объекта даты, для которого вы его вызвали (однако я не могу проверить, чтобы это было стандартным).

В моем браузере добавление 60000 * Date.getTimezoneOffset () создает DateTime, который не является UTC . Однако, когда отображается в моем браузере (например: .toString ()), он отображает DateTime в моем местном часовом поясе, который будет правильным временем UTC, если информация о часовом поясе игнорируется.

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

Другое решение для преобразования в UTC и сохранения его как объекта даты: (Он работает, удаляя часть 'GMT' из конца отформатированной строки, а затем возвращая ее обратно в конструктор Date)

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

Мне нужно было сделать это для взаимодействия с библиотекой выбора даты и времени. Но в целом работать с датами в таком случае - плохая идея.

Пользователи обычно хотят работать с датами и временем по местному времени, поэтому вы либо обновляете код на стороне сервера, чтобы правильно анализировать строки даты и времени со смещениями, затем конвертируете в UTC (лучший вариант) или конвертируете в строку UTC на стороне клиента перед отправкой в сервер (как в ответе Уилла Стерна)

Вы пытаетесь преобразовать дату в такую ​​строку?

Я бы сделать функцию, чтобы сделать это, и, хотя это немного спорно, добавить его к дате прототипа. Если вам неудобно делать это, то вы можете поместить это как отдельную функцию, передавая дату в качестве параметра.

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

Если вам это нужно во время UTC, просто замените все функции get * на getUTC *, например: getUTCFullYear, getUTCMonth, getUTCHours ..., а затем просто добавьте «+00: 00» в конце вместо смещения часового пояса пользователя.

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

должен работать в большинстве новых браузеров. возвращается 2012-07-28T00:00:00.000Zна Firefox 6.0

Моя рекомендация при работе с датами - разбирать дату на отдельные поля из пользовательского ввода. Вы можете использовать его как полную строку, но вы играете с огнем.

JavaScript может обрабатывать две одинаковые даты в разных форматах по-разному.

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

Никогда не делайте ничего подобного:

new Date('date as text');

После того как ваша дата будет проанализирована в отдельных полях из пользовательского ввода, создайте объект даты. Как только объект даты создан, преобразуйте его в UTC, добавив смещение часового пояса. Я не могу не подчеркнуть, насколько важно использовать смещение от объекта даты из-за перехода на летнее время (это еще одно обсуждение, чтобы показать, почему).

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

Теперь вы можете передать дату на сервер по UTC времени. Опять же, я бы настоятельно рекомендовал не использовать любые строки даты. Либо передайте его на сервер с минимальной степенью детализации, необходимой вам, например, год, месяц, день, минута, либо в виде значения, например, в миллисекундах, начиная с эпохи Unix.

Если вы много имеете дело с датами, стоит использовать moment.js ( http://momentjs.com ). Метод для преобразования в UTC будет:

moment(yourTime).utc()

Вы можете использовать формат для изменения даты на любой другой формат:

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

Также есть опции смещения, но есть дополнительная дополнительная библиотека для работы с часовым поясом ( http://momentjs.com/timezone/ ). Преобразование времени будет так просто:

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

Мое решение сохраняет дату неизменной независимо от того, какой часовой пояс установлен на стороне клиента. Может быть, кто-то найдет это полезным.

Мой вариант использования:

Я создаю приложение todo, в котором вы устанавливаете дату своей задачи. Эта дата должна оставаться постоянной независимо от того, в каком часовом поясе вы находитесь.

Пример. Вы хотите позвонить своему другу в 8 часов утра 25 июня.

Вы создаете это задание за 5 дней до (20 июня), пока находитесь в Китае.

Затем в тот же день вы летите в Нью-Йорк на несколько дней.

Затем, 25 июня, когда вы все еще находитесь в Нью-Йорке, вы просыпаетесь в 7:30 утра (что означает, что вы должны получить уведомление о задании в течение 30 минут (даже если это 13:30 уже в Китае, где вы были при создании задача)

Таким образом, задача - игнорировать часовой пояс. Это означает: «Я хочу сделать это в 8 часов утра в любом часовом поясе».

Что я делаю, скажем так: «Я полагаю, вы всегда в лондонском часовом поясе - UTC».

Что это означает - когда пользователь выбирает какую-либо дату в своем часовом поясе - я конвертирую эту дату в ту же дату в UTC. то есть. Вы выбираете 8 утра в Китае, но я конвертирую его в 8 утра в UTC.

Затем - в следующий раз, когда вы откроете приложение - я прочитал дату, сохраненную в UTC, и конвертировал ее в ту же дату в вашем текущем часовом поясе, например. Я конвертирую 8 часов утра в UTC в 8 часов утра в часовом поясе Нью-Йорка.

Это решение означает, что дата может означать что-то другое, в зависимости от того, где вы находитесь при ее установке и где вы ее читаете, но она остается постоянной, так что вам кажется, что вы всегда находитесь в одном и том же часовом поясе.

Давайте напишем некоторый код:

Во-первых, у нас есть две основные функции для преобразования из / в UTC, игнорируя часовой пояс:

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

Затем я сохраняю / читаю эту дату как:

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
}

Я только что обнаружил, что версия date.format.js Стивена Левитана 1.2.3 делает именно то, что я хочу. Это позволяет вам предоставить строку формата для даты JavaScript и конвертировать из местного времени в UTC. Вот код, который я сейчас использую:

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

Я нашел, что анализ даты плагинов глобализации jQuery работает лучше всего. Другие методы имели проблемы с кроссбраузерностью, и такие вещи, как date.js, давно не обновлялись.

Вам также не нужен DatePicker на странице. Вы можете просто вызвать что-то похожее на пример, приведенный в документации:

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

Эта функция прекрасно работает для меня.

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

Использование 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)));

Это даст вам правильную дату и время UTC.
Это потому, что getTimezoneOffset()даст вам разницу часовых поясов в минутах. Я рекомендую вам не использовать, toISOString()потому что вывод будет в строке. Следовательно, в будущем вы не сможете манипулировать датой.

Это то, что я сделал в прошлом:

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

Если вам нужен объект Date

Передача только строки даты Date предполагает, что время сдвигается на 00:00 по часовому поясу:

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

Если вы добавите текущие часы и минуты, вы получите правильную дату:

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

Глядя на ваш вопрос, становится ясно, что вы просто хотите отправить диапазон дат в свой бэкэнд для дальнейшей постобработки.

Я предполагаю, что вы соответствуете стандартным рекомендациям по данным, которые предполагают, что данные будут в определенном формате. Например, я использую ODATA, который представляет собой RESTfull API, который ожидает, что объекты даты и времени будут в формате: -

YYYY-MM-DDT00: 00: 00.

Это может быть легко достигнуто с помощью фрагмента, размещенного ниже (пожалуйста, измените формат согласно вашему требованию).

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

Если, с другой стороны, вы находитесь в моей ситуации, когда вы получили дату от своего бэкэнда, и браузер преобразует ее в вашу локальную дату. Вы, с другой стороны, заинтересованы в дате UTC, тогда вы можете выполнить следующее: -

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

Приведенный выше фрагмент кода в основном добавляет / вычитает время, добавляемое / вычитаемое браузером, на основе часового пояса.

Например, если я нахожусь в EST (GMT-5), и моя служба возвращает объект даты и времени = ср. 17 августа 2016 00:00:00 GMT-0500, мой браузер автоматически вычитает смещение часового пояса (5 часов), чтобы узнать мое местное время. Поэтому, если я попытаюсь получить время, я получу ср 16 августа 2016 19:00:00 GMT-0500. Это вызывает много проблем. Есть много библиотек, которые определенно сделают это проще, но я хотел бы поделиться чистым подходом JS.

Для получения дополнительной информации, пожалуйста, посмотрите на: http://praveenlobo.com/blog/how-to-convert-javascript-local-date-to-utc-and-utc-to-local-date/ где я получил мой вдохновение.

Надеюсь это поможет!

Этот метод даст вам: 2017-08-04T11:15:00.000+04:30и вы можете игнорировать переменную зоны, чтобы просто получить 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;
}

Используя пакет момента, вы можете легко преобразовать строку даты UTC в новый объект Date:

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

Это особенно помогает, когда ваш сервер не поддерживает часовой пояс, и вы хотите всегда сохранять дату UTC на сервере и возвращать ее как новый объект Date. Выше код работал для моего требования аналогичной проблемы, что этот поток для. Поделиться здесь, чтобы помочь другим. Я не вижу точно вышеуказанного решения ни в одном ответе. Спасибо.

константное событие = новая дата ();

console.log (event.toUTCString ());

Я знаю, что этот вопрос старый, но рассматривал эту же проблему, и одним из вариантов будет отправка date.valueOf () на сервер. Функция valueOf () javascript Date отправляет количество миллисекунд с полуночи 1 января 1970 года UTC.

значение()

Так что это был способ, которым я должен был это сделать, потому что я все еще хотел, чтобы объект даты в JavaScript манипулировал как дата, и, к сожалению, многие из этих ответов требуют от вас перехода к строке.

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

пряжа добавить момент

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;

}

Еще проще

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