Bir JavaScript tarihini UTC'ye nasıl dönüştürürsünüz?

Web sitenizdeki bir kullanıcının bir tarih aralığı girdiğini varsayalım.

2009-1-1 to 2009-1-3

Bazı işlemler için bu tarihi bir sunucuya göndermeniz gerekir, ancak sunucu tüm tarih ve saatlerin UTC'de olmasını bekler.

Şimdi kullanıcının Alaska veya Hawaii veya Fiji'de olduğunu varsayalım. UTC'den oldukça farklı bir saat diliminde olduklarından, tarih aralığının aşağıdaki gibi bir şeye dönüştürülmesi gerekir:

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

JavaScript Date nesnesini kullanarak, ilk "yerelleştirilmiş" tarih aralığını sunucunun anlayacağı bir şeye nasıl dönüştürürdünüz?

toISOString()Yöntem basitleştirilmiş genişletilmiş ISO formatında (bir dize döndürür ISO 8601 daima 24 veya 27 karakter uzunluğunda (olduğu), YYYY-MM-DDTHH:mm:ss.sssZveya ±YYYYYY-MM-DDTHH:mm:ss.sssZsırasıyla). Saat dilimi her zaman " Z" son ekiyle belirtildiği gibi sıfır UTC uzaklığıdır .

Kaynak: MDN web dokümanları

İhtiyaç duyduğunuz format .toISOString()yöntemle oluşturulur . Bu yöntemi yerel olarak desteklemeyen eski tarayıcılar (yani 8 ve altı) için, şim burada bulunabilir :

Bu, ihtiyacınız olanı yapma yeteneğini verecektir:

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

Timezone çalışması için moment.js ve moment.js timezone gerçekten paha biçilmez araçlar ... özellikle istemci ve sunucu javascriptleri arasında zaman dilimleri arasında gezinmek için.

Basit ve aptalca

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

İşte benim yöntem:

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

Ortaya çıkan utcnesne gerçekten bir UTC tarihi değil, yerel bir tarih UTC saatiyle eşleşecek şekilde değişti (yorumlara bakın). Ancak, pratikte bu işi yapar.

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

Tarih / saati değiştirmeden ISO'ya dönüştürün

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

Tarih / saat değişikliği ile ISO'ya dönüştürün (tarih / saat değişecektir)

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

Keman bağı

Tarayıcılar farklı olabilir ve istemci tarafından oluşturulan herhangi bir bilgiye güvenmemeyi de unutmamalısınız, aşağıdaki ifade benim için işe yarıyor (Mac OS X 10.8.2'de Google Chrome v24)

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

edit: "Bu sadece farklı nasıl new Date()?" buraya bakın: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

• Herhangi bir bağımsız değişken sağlanmazsa, kurucu sistem ayarlarına göre geçerli tarih ve saat için bir JavaScript Tarihi nesnesi oluşturur.
• Not: Tarih, birden fazla bağımsız değişkeni olan bir kurucu olarak çağrıldığında, belirtilen bağımsız değişkenler yerel saati temsil eder. UTC isteniyorsa, aynı bağımsız değişkenlerle yeni Date ( Date.UTC (...) ) kullanın . (not: Date.UTC (), 1970-01-01 00:00:00 UTC'den beri milisaniye sayısını döndürür)

Önceki yanıtların belirttiği gibi 60000 * Date.getTimezoneOffset () eklenmesi yanlıştır. İlk olarak, tüm Tarihleri ​​/ Saatleri görüntüleme amaçları için bir saat dilimi değiştiricisiyle UTC olarak düşünmelisiniz.

Yine, tarayıcılar farklı olabilir, ancak Date.getTime (), 1970-01-01 UTC / GMT'den bu yana milisaniye sayısını döndürür. Bu sayıyı yukarıda yaptığım gibi kullanarak yeni bir Tarih oluşturursanız, UTC / GMT olur. Ancak, .toString () öğesini çağırarak görüntülerseniz, .toString () öğesi çağrıldığı Date nesnesinin saat dilimini değil, yerel saat diliminizi kullandığından yerel saat diliminizde görünür.

Ben de bir tarihte .getTimezoneOffset () çağırırsanız, yerel saat dilimi, aradığınız tarih nesnesinin saat dilimi döndürmez (Bu ancak standart olarak doğrulayamıyorum).

Tarayıcımda, 60000 * Date.getTimezoneOffset () eklendiğinde UTC olmayan bir DateTime oluşturulur . Ancak tarayıcımda görüntülendiğinde (ör: .toString ()), yerel saat dilimimde, saat dilimi bilgisi yoksayılırsa doğru UTC saatini gösteren bir DateTime görüntüler.

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

UTC'ye dönüştürmek ve bir tarih nesnesi olarak tutmak için başka bir çözüm: (Biçimlendirilmiş dizenin sonundan 'GMT' bölümünü kaldırarak, ardından Tarih yapıcısına geri koyarak çalışır)

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

Bunu datetime seçici kitaplığıyla arabirim oluşturmak için yapmam gerekiyordu. Ancak genel olarak tarihlerle bu şekilde çalışmak kötü bir fikirdir.

Kullanıcılar genellikle yerel saatlerinde dattime ile çalışmak isterler, bu nedenle ya datetime dizelerini ofsetlerle doğru şekilde ayrıştırmak için sunucu tarafı kodunu güncellersiniz, sonra UTC'ye (en iyi seçenek) dönüştürür ya da göndermeden önce bir UTC dizesine dönüştürürsünüz sunucusu (Will Stern'in cevabındaki gibi)

Tarihi böyle bir dizeye dönüştürmeye mi çalışıyorsunuz?

Bunu yapmak için bir işlev yapacağım ve biraz tartışmalı olsa da, Date prototipine ekleyeceğim. Bunu yapmaktan memnun değilseniz, tarihi parametre olarak ileterek bağımsız bir işlev olarak koyabilirsiniz.

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 zamanında ihtiyacınız varsa, tüm get * işlevlerini getUTC * ile değiştirin, örneğin: getUTCFullYear, getUTCMonth, getUTCHours ... ve sonra kullanıcının saat dilimi farkı yerine "+00: 00" ekleyin.

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

en yeni tarayıcılarda çalışmalıdır. 2012-07-28T00:00:00.000ZFirefox 6.0'da geri dönüyor

Tarihlerle çalışırken önerim, tarihi kullanıcı girişinden ayrı alanlara ayrıştırmaktır. Tam dize olarak kullanabilirsiniz, ancak ateşle oynuyorsunuz.

JavaScript, iki eşit tarihi farklı biçimlerde farklı şekilde ele alabilir.

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

Asla böyle bir şey yapmayın:

new Date('date as text');

Tarihinizi kullanıcı girdisinden ayrı alanlarına ayrıştırdıktan sonra bir tarih nesnesi oluşturun. Tarih nesnesi oluşturulduktan sonra, saat dilimi uzaklığını ekleyerek onu UTC'ye dönüştürün. DST nedeniyle tarih nesnesinden uzaklığı kullanmanın ne kadar önemli olduğunu vurgulayamıyorum (ancak bunun nedenini göstermek için başka bir tartışma).

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

Artık tarihi UTC'ye saatte sunucuya aktarabilirsiniz. Yine herhangi bir tarih dizeleri kullanarak karşı tavsiye. Ya sunucuya, örneğin yıl, ay, gün, dakika ya da unix çağından milisaniye gibi bir değer olarak ihtiyacınız olan en düşük ayrıntı düzeyine ayrılmış olarak iletin.

Tarihlerle çok uğraşıyorsanız, moment.js ( http://momentjs.com ) kullanmaya değer . UTC'ye dönüştürme yöntemi şu şekildedir:

moment(yourTime).utc()

Tarihinizi istediğiniz herhangi bir biçime değiştirmek için biçimi kullanabilirsiniz:

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

Şu anda ofset seçenekleri de var, ancak saat dilimi ile ilgili ek bir tamamlayıcı kütüphane var ( http://momentjs.com/timezone/ ). Zaman dönüşümü şu kadar basit olurdu:

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

Çözümüm, istemci tarafında hangi saat dilimi ayarlanmış olursa olsun tarihi aynı tutar. Belki birisi bunu faydalı bulabilir.

Kullanım durumum:

Görevinizin tarihini ayarladığınız bir todo uygulaması oluşturuyorum. Hangi tarih diliminde olursanız olun bu tarih sabit kalmalıdır.

Misal. 25 Haziran günü sabah 8'de arkadaşınızı aramak istiyorsunuz.

Bu görevi Çin'deyken 5 gün (20 Haziran) önce yaratırsınız.

Aynı gün, birkaç gün New York'a uçuyorsunuz.

Daha sonra 25 Haziran'da, hala New York'dayken, sabah 7: 30'da uyanıyorsunuz (yani 30 dakika içinde görev bildirimi almanız gerekiyor (hatta Çin'de oluşturduğunuz saat 13: 30'da bile) görev)

Yani görev saat dilimini görmezden gelmek. 'Ben saat 8'de bunu yapmak istediğim saat diliminde yapmak istiyorum' anlamına gelir.

Yaptığım şey 'Her zaman Londra Saat Dilimi - UTC'de olduğunuzu varsayıyorum' diyelim.

Bunun anlamı - kullanıcı saat diliminde bir tarih seçtiğinde - bu tarihi UTC'de aynı tarihe dönüştürürüm. yani. Çin'de sabah 8'i seçiyorsunuz, ancak UTC'de sabah 8'e dönüştürüyorum.

Sonra - uygulamayı bir sonraki açışınızda - UTC'de kaydedilen tarihi okudum ve geçerli saat diliminizde aynı tarihe dönüştürüyorum - ör. UTC'de 8.00'i New York saat diliminde 8'e dönüştürüyorum.

Bu çözüm, tarihin ayarladığınız yere ve okuduğunuz yere bağlı olarak başka bir şey ifade edebileceği anlamına gelir, ancak her zaman aynı saat dilimindeymişsiniz gibi hissedecek şekilde sabit kalır.

Biraz kod yazalım:

İlk olarak - saat dilimini yoksaymak / UTC'yi dönüştürmek için 2 ana fonksiyonumuz var:

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

Sonra, bu tarihi aşağıdaki gibi kaydeder / okurum:

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
}

Steven Levithan'ın date.format.js dosyasının 1.2.3 sürümünün tam olarak istediğimi yaptığını keşfettim . JavaScript tarihi için bir biçim dizesi sağlamanıza olanak tanır ve yerel saatten UTC'ye dönüşür. İşte şimdi kullanıyorum kodu:

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

En iyi şekilde çalışmak için jQuery Globalization Plugin tarih ayrıştırma buldum . Diğer yöntemlerde tarayıcılar arası sorunlar vardı ve date.js gibi şeyler bir süredir güncellenmedi.

Sayfada bir datePicker seçeneğine de ihtiyacınız yoktur. Yalnızca dokümanlarda verilen örneğe benzer bir şey arayabilirsiniz:

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

Bu işlev benim için güzel çalışıyor.

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

Moment.js UTC yöntemini kullanarak ;

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

Bu size uygun UTC Tarih ve Saatini verecektir.
Çünkü getTimezoneOffset()dakika cinsinden saat dilimi farkını vereceksiniz. toISOString()Çıktı dizede olacağından kullanmamanızı tavsiye ederim Bu nedenle gelecekte tarihi değiştiremezsiniz

Geçmişte yaptığım şey bu:

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

Tarih Nesnesine ihtiyacınız varsa

Yalnızca tarih dizesini iletme Tarih, saatin saat dilimine göre 00:00 olarak değiştirildiğini varsayar:

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

Geçerli saatleri ve dakikaları eklerseniz uygun tarih alırsınız:

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

Sorunuza baktığınız zaman, daha sonraki post işleme için tarih aralığını arka ucunuza göndermek istediğiniz açıktır.

Verilerin belirli bir biçimde olmasını bekleyen standart veri yönergelerine uyduğunuzu varsayıyorum. Örneğin, tarih nesnesi biçiminde olmasını bekleyen bir RESTfull API olan ODATA kullanın: -

YYYY-AA-DDT00: 00: 00.

Bu, aşağıda yayınlanan snippet ile kolayca elde edilebilir (Lütfen gereksiniminize göre biçimi değiştirin).

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

Öte yandan, benim durumumda, arka uçtan bir tarih aldınız ve tarayıcı bunu yerel tarihinize dönüştürür. Öte yandan UTC tarihi ile ilgileniyorsanız o zaman aşağıdakileri yapabilirsiniz: -

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

Yukarıdaki kod snippet'i, temel olarak, saat dilimini temel alarak tarayıcı tarafından eklenen / çıkarılan zamanı ekler / çıkarır.

Örneğin, EST'deyim (GMT-5) ve Hizmetim bir tarih saat nesnesi döndürürse = Çar 17 Ağustos 2016 00:00:00 GMT-0500 Tarayıcım yerel saatimi almak için saat dilimi farkını (5 saat) otomatik olarak çıkarır. Yani zaman getirmeye çalışırsam Çar 16 Ağustos 2016 19:00:00 GMT-0500 olsun. Bu birçok soruna neden olur. Orada kesinlikle bunu kolaylaştıracak birçok kütüphane var ama saf JS yaklaşımını paylaşmak istedim.

Daha fazla bilgi için lütfen şu adrese göz atın: http://praveenlobo.com/blog/how-to-convert-javascript-local-date-to-utc-and-utc-to-local-date/ nerede var ilham.

Bu yardımcı olur umarım!

Bu yöntem size: 2017-08-04T11:15:00.000+04:30ve almak için bölge değişkenini göz ardı edebilirsiniz 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;
}

Moment paketini kullanarak UTC tarih dizesini kolayca yeni bir Date nesnesine dönüştürebilirsiniz:

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

Bu özellikle sunucunuz saat dilimini desteklemediğinde ve UTC tarihini her zaman sunucuda saklamak ve yeni bir Date nesnesi olarak geri almak istediğinizde yardımcı olur. Yukarıdaki kod bu konu için benzer sorun benim gereksinimi için çalıştı. Burada paylaşarak başkalarına yardımcı olabilir. Herhangi bir cevapta tam olarak yukarıdaki çözümü görmüyorum. Teşekkürler.

const event = yeni Date ();

console.log (event.toUTCString ());

Bu sorunun eski olduğunu biliyorum, ama aynı soruna bakıyordu ve bir seçenek bunun yerine sunucuya date.valueOf () göndermek olacaktır. javascript Date öğesinin valueOf () işlevi, 1 Ocak 1970 UTC gece yarısından bu yana geçen milisaniye sayısını gönderir.

değeri()

Bu yüzden bunu yapmak zorundayım yolu çünkü hala bir tarih olarak işlemek için bir JavaScript tarih nesnesi istedim ve ne yazık ki bu cevapların bir sürü bir dize gitmenizi gerektirir.

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

iplik ekleme anı

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;

}

Daha da basit

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