Birinci Durum:

new Date(Date.parse("Jul 8, 2005"));

Çıktı:

Cum 08 Temmuz 2005 00:00:00 GMT-0700 (PST)

İkinci Durum:

new Date(Date.parse("2005-07-08"));

Çıktı:

Perşembe 07 Temmuz 2005 17:00:00 GMT-0700 (PST)

İkinci ayrıştırma neden yanlış?

5. sürüm Spec çıktı kadar, Date.parseyöntem tamamen idi bağımlı uygulama ( new Date(string)eşdeğerdir Date.parse(string)bir daha sayı oldukça ikincisi döner hariç Date). 5. sürüm spesifikasyonunda, basitleştirilmiş (ve biraz yanlış) bir ISO-8601'i desteklemek için gereksinim eklenmiştir (ayrıca bkz . JavaScript'te geçerli Tarih Saat Dizeleri nedir? ). Ancak bunun dışında, neyin kabul edileceğine / neyin kabul edileceğine dair herhangi bir gereklilik yoktu (bunun ne olduğunu söylemeden).Date.parsenew Date(string)Date#toString

ECMAScript 2017 (sürüm 8) itibariyle, çıktılarının Date#toStringve için ayrıştırılması gerekiyordu Date#toUTCString, ancak bu dizelerin formatı belirtilmedi.

ECMAScript'te 2019 da (baskı 9) biçimi itibarıyla Date#toStringve Date#toUTCString, (sırasıyla) olarak belirtilmiştir:

1. gg AAA MMY GG YYYY SS: dd: ss ZZ [(saat dilimi adı)]
   ör. Sal 10 Temmuz 2018 18:39:58 GMT + 0530 (IST)
2. gg.aa, GG MMM YYYY SS: dd: ss Z
   ör. Sal 10 Tem 2018 13:09:58 GMT

Date.parseyeni uygulamalarda güvenilir bir şekilde ayrıştırılması gereken 2 biçim daha sağlamak (desteğin her yerde bulunmadığını ve uyumlu olmayan uygulamaların bir süre kullanılmaya devam edeceğini belirtmek).

Tarih dizelerinin manuel olarak ayrıştırılmasını ve belirsizlikten kaçınmak için yıl, ay ve gün değişkenleriyle Tarih yapıcısının kullanılmasını öneriyorum :

// parse a date in yyyy-mm-dd format
function parseDate(input) {

  let parts = input.split('-');

  // new Date(year, month [, day [, hours[, minutes[, seconds[, ms]]]]])
  return new Date(parts[0], parts[1]-1, parts[2]); // Note: months are 0-based
}

Son zamanlarda bir JS tercümanı yazarken, ECMA / JS tarihlerinin iç çalışmaları ile bolca güreştim. Yani, 2 sentimi buraya atacağım. Umarım bu şeyleri paylaşmak, başkalarının tarayıcılar arasındaki tarihleri ​​nasıl ele aldıkları arasındaki farklar hakkında herhangi bir soru sormasına yardımcı olur.

Giriş Tarafı

Tüm uygulamalar, tarih değerlerini dahili olarak 1970-01-01 UTC'den (GMT, UTC ile aynı şeydir) milisaniye (ms) sayısını temsil eden 64 bitlik sayılar olarak depolar. Bu tarih, Java ve UNIX gibi POSIX sistemleri gibi diğer diller tarafından da kullanılan ECMAScript çağıdır. Dönemden sonraki tarihler pozitif sayılardır ve önceki tarihler negatiftir.

Aşağıdaki kod, tüm geçerli tarayıcılarda aynı tarih olarak yorumlanır, ancak yerel saat dilimi uzaklığı ile yorumlanır:

Date.parse('1/1/1970'); // 1 January, 1970

Saat dilimimde (-05: 00 olan EST) sonuç 18000000 olur, çünkü bu 5 saatte kaç ms'dir (gün ışığından yararlanma aylarında sadece 4 saattir). Değer, farklı saat dilimlerinde farklı olacaktır. Bu davranış ECMA-262'de belirtilmiştir, böylece tüm tarayıcılar bunu aynı şekilde yapar.

Giriş dizesi formatlarında büyük tarayıcıların tarih olarak ayrıştıracağı bir miktar farklılık olsa da, ayrıştırma büyük ölçüde uygulamaya bağlı olsa bile, esas olarak bunları saat dilimleri ve gün ışığından yararlanma söz konusu olduğunda aynı şekilde yorumlarlar.

Ancak, ISO 8601 biçimi farklıdır. ECMAScript 2015'te (ed 6) özetlenen, özellikle tüm uygulamalar tarafından aynı şekilde ayrıştırılması gereken iki formattan biridir (diğeri Date.prototype.toString için belirtilen formattır ).

Ancak, ISO 8601 biçim dizeleri için bile, bazı uygulamalar yanlış anlıyor. Bu yanıt ilk olarak 1/1/1970 (dönem) için , tüm uygulamalarda tam olarak aynı değere ayrıştırılması gereken ISO 8601 biçim dizeleri kullanılarak makinemde yazıldığında Chrome ve Firefox'un bir karşılaştırma çıktısıdır :

Date.parse('1970-01-01T00:00:00Z');       // Chrome: 0         FF: 0
Date.parse('1970-01-01T00:00:00-0500');   // Chrome: 18000000  FF: 18000000
Date.parse('1970-01-01T00:00:00');        // Chrome: 0         FF: 18000000

• İlk durumda, "Z" belirteci, girişin UTC saatinde olduğunu, bu nedenle çağdan uzak olmadığını ve sonucun 0 olduğunu belirtir.
• İkinci durumda, "-0500" belirteci girişin GMT-05: 00'da olduğunu ve her iki tarayıcı da girişi -05: 00 saat diliminde olduğunu yorumlar. Bu, UTC değerinin çağdan mahsup edildiği anlamına gelir; bu da tarihin dahili zaman değerine 18000000ms eklenmesi anlamına gelir.
• Herhangi bir belirteç bulunmayan üçüncü durum, ana sistem için yerel olarak ele alınmalıdır . FF, girişi yerel saat olarak doğru bir şekilde ele alırken Chrome, UTC'yi olarak ele alır ve böylece farklı zaman değerleri üretir. Benim için bu saklı değerde 5 saatlik bir fark yaratıyor, ki bu sorunlu. Farklı ofsetleri olan diğer sistemler farklı sonuçlar alacaktır.

Bu fark 2020 itibariyle düzeltildi, ancak ISO 8601 biçim dizelerini ayrıştırırken tarayıcılar arasında başka tuhaflıklar var.

Ama daha da kötüleşiyor. ECMA-262'nin tuhaflığı, ISO 8601 yalnızca tarih biçiminin (YYYY-AA-GG) UTC olarak ayrıştırılması gerektiğinde, ISO 8601'in yerel olarak ayrıştırılması gerekiyor. Burada, zaman dilimi belirticisi olmayan uzun ve kısa ISO tarih formatları ile FF'den çıktı.

Date.parse('1970-01-01T00:00:00');       // 18000000
Date.parse('1970-01-01');                // 0

Dolayısıyla ilki yerel olarak ayrıştırılır, çünkü saat dilimi olmadan ISO 8601 tarih ve saati, ikincisi ise yalnızca ISO 8601 tarihi olduğu için UTC olarak ayrıştırılır.

Bu nedenle, orijinal soruyu doğrudan cevaplamak için "YYYY-MM-DD"ECMA-262'nin UTC olarak yorumlanması, diğerinin ise yerel olarak yorumlanması gerekir. Bu yüzden:

Bu eşdeğer sonuçlar üretmez:

console.log(new Date(Date.parse("Jul 8, 2005")).toString()); // Local
console.log(new Date(Date.parse("2005-07-08")).toString());  // UTC

Bu yapar:

console.log(new Date(Date.parse("Jul 8, 2005")).toString());
console.log(new Date(Date.parse("2005-07-08T00:00:00")).toString());

Sonuç olarak, tarih dizelerini ayrıştırmak için bu satır. Tarayıcılar arasında güvenle ayrıştırabileceğiniz SADECE ISO 8601 dizesi, ofseti olan uzun formdur (± HH: mm veya "Z"). Bunu yaparsanız, yerel ve UTC saati arasında güvenle ileri geri gidebilirsiniz.

Bu, tarayıcılarda çalışır (IE9'dan sonra):

console.log(new Date(Date.parse("2005-07-08T00:00:00Z")).toString());

Mevcut tarayıcıların çoğu, sık kullanılan '1/1/1970' (M / D / YYYY) ve '1/1/1970 00:00:00 AM' (M / D / YYYY ss) dahil olmak üzere diğer giriş biçimlerine eşit davranır. : mm: ss ap) biçimleri. Aşağıdaki biçimlerin tümü (sonuncusu hariç) tüm tarayıcılarda yerel saat girişi olarak kabul edilir. Bu kodun çıktısı saat dilimimdeki tüm tarayıcılarda aynı. Son zaman ana bilgisayar saat diliminden bağımsız olarak -05: 00 olarak değerlendirilir, çünkü uzaklık zaman damgasında ayarlanır:

console.log(Date.parse("1/1/1970"));
console.log(Date.parse("1/1/1970 12:00:00 AM"));
console.log(Date.parse("Thu Jan 01 1970"));
console.log(Date.parse("Thu Jan 01 1970 00:00:00"));
console.log(Date.parse("Thu Jan 01 1970 00:00:00 GMT-0500"));

Bununla birlikte, ECMA-262'de belirtilen formatların bile ayrıştırılması tutarlı olmadığından, yerleşik ayrıştırıcıya asla güvenmemeniz ve dizeleri her zaman manuel olarak ayrıştırmanız, örneğin bir kitaplık kullanmanız ve ayrıştırıcıya format sağlamanız önerilir.

Örneğin moment.js içinde şunları yazabilirsiniz:

let m = moment('1/1/1970', 'M/D/YYYY'); 

Çıktı Tarafı

Çıktı tarafında, tüm tarayıcılar saat dilimlerini aynı şekilde çevirir, ancak dize biçimlerini farklı şekilde işler. İşte toStringfonksiyonları ve çıktıları. toUTCStringVe toISOStringfonksiyonları makinemde 05:00 AM çıktı dikkat edin . Ayrıca, saat dilimi adı bir kısaltma olabilir ve farklı uygulamalarda farklı olabilir.

Yazdırmadan önce UTC'den Yerel saate dönüştürür

 - toString
 - toDateString
 - toTimeString
 - toLocaleString
 - toLocaleDateString
 - toLocaleTimeString

Depolanan UTC saatini doğrudan yazdırır

 - toUTCString
 - toISOString 

Chrome'da

toString            Thu Jan 01 1970 00:00:00 GMT-05:00 (Eastern Standard Time)
toDateString        Thu Jan 01 1970
toTimeString        00:00:00 GMT-05:00 (Eastern Standard Time)
toLocaleString      1/1/1970 12:00:00 AM
toLocaleDateString  1/1/1970
toLocaleTimeString  00:00:00 AM

toUTCString         Thu, 01 Jan 1970 05:00:00 GMT
toISOString         1970-01-01T05:00:00.000Z

Firefox'ta

toString            Thu Jan 01 1970 00:00:00 GMT-05:00 (Eastern Standard Time)
toDateString        Thu Jan 01 1970
toTimeString        00:00:00 GMT-0500 (Eastern Standard Time)
toLocaleString      Thursday, January 01, 1970 12:00:00 AM
toLocaleDateString  Thursday, January 01, 1970
toLocaleTimeString  12:00:00 AM

toUTCString         Thu, 01 Jan 1970 05:00:00 GMT
toISOString         1970-01-01T05:00:00.000Z

Normalde dize girişi için ISO biçimini kullanmıyorum. Bu biçimi kullanmanın benim için yararlı olduğu tek zaman, tarihlerin dizeler olarak sıralanması gerektiğidir. ISO formatı diğerleri gibi sıralanabilir. Tarayıcılar arası uyumluluğunuz olması gerekiyorsa, saat dilimini belirtin veya uyumlu bir dize biçimi kullanın.

Kod new Date('12/4/2013').toString()aşağıdaki dahili sözde dönüşümden geçer:

  "12/4/2013" -> toUCT -> [storage] -> toLocal -> print "12/4/2013"

Umarım bu cevap yardımcı olmuştur.

Deliliğin bir yolu var. Genel bir kural olarak, bir tarayıcı bir tarihi ISO-8601 olarak yorumlayabilirse, bunu yapar. "2005-07-08" bu kampa giriyor ve UTC olarak ayrıştırılıyor. "8 Tem 2005" yapılamaz ve bu nedenle yerel saatte ayrıştırılır.

Bkz JavaScript ve Tarihler, Ne Mess! daha fazlası için.

Başka bir çözüm, tarih biçimiyle ilişkilendirilebilir bir dizi oluşturmak ve ardından verileri yeniden biçimlendirmektir.

Bu yöntem, olağandışı bir şekilde biçimlendirilmiş tarih için kullanışlıdır.

Bir örnek:

    mydate='01.02.12 10:20:43':
    myformat='dd/mm/yy HH:MM:ss';


    dtsplit=mydate.split(/[\/ .:]/);
    dfsplit=myformat.split(/[\/ .:]/);

    // creates assoc array for date
    df = new Array();
    for(dc=0;dc<6;dc++) {
            df[dfsplit[dc]]=dtsplit[dc];
            }

    // uses assc array for standard mysql format
    dstring[r] = '20'+df['yy']+'-'+df['mm']+'-'+df['dd'];
    dstring[r] += ' '+df['HH']+':'+df['MM']+':'+df['ss'];

Tarihleri ​​ayrıştırmak için moment.js'yi kullanın :

var caseOne = moment("Jul 8, 2005", "MMM D, YYYY", true).toDate();
var caseTwo = moment("2005-07-08", "YYYY-MM-DD", true).toDate();

3. argüman katı ayrıştırmayı belirler (2.3.0'dan itibaren mevcuttur). Onsuz moment.js ayrıca yanlış sonuçlar verebilir.

Göre http://blog.dygraphs.com/2012/03/javascript-and-dates-what-mess.html biçimi "yyyy / mm / dd" çözer olağan problemler. Diyor ki: "Mümkün olduğunca tarih dizeleriniz için" YYYY / AA / GG'ye sadık kalın. Evrensel olarak destekleniyor ve belirsiz. Bu formatla tüm zamanlar yerel. " Testler ayarladım: http://jsfiddle.net/jlanus/ND2Qg/432/ Bu biçim: + ymd siparişini kullanarak gün ve ay emri belirsizliğini önler ve 4 basamaklı bir yıl + UTC ile yerel sorunu önler eğik çizgiler + danvk kullanarak ISO formatına uymak olan dygraphs adamı, bu formatın tüm tarayıcılarda iyi olduğunu söylüyor.

CMS, dizeleri ayrıştırma yöntemine geçirmenin genellikle güvensiz olduğu konusunda doğru olsa da , bölüm 15.9.4.2'deki yeni ECMA-262 5. Baskı (aka ES5) belirtimiDate.parse() ISO formatlı tarihleri ​​gerçekten işlemesi gerektiğini . Eski şartname böyle bir iddiada bulunmadı. Tabii ki, eski tarayıcılar ve bazı mevcut tarayıcılar hala bu ES5 işlevselliğini sağlamaz.

İkinci örneğiniz yanlış değil. Belirtildiği gibi UTC'de belirtilen tarihtir Date.prototype.toISOString(), ancak yerel saat diliminizde temsil edilir.

Bu hafif tarih ayrıştırma kitaplığı tüm benzer sorunları çözmelidir. Kütüphaneyi seviyorum çünkü uzatılması oldukça kolay. Ayrıca i18n de mümkündür (çok düz değil, ama o kadar zor değil).

Ayrıştırma örneği:

var caseOne = Date.parseDate("Jul 8, 2005", "M d, Y");
var caseTwo = Date.parseDate("2005-07-08", "Y-m-d");

Ve dizeye geri biçimlendirme (her iki durumda da aynı sonucu verdiğini fark edeceksiniz):

console.log( caseOne.dateFormat("M d, Y") );
console.log( caseTwo.dateFormat("M d, Y") );
console.log( caseOne.dateFormat("Y-m-d") );
console.log( caseTwo.dateFormat("Y-m-d") );

İşte kısa, esnek bir snippet, tarayıcı zamanına uygun bir dizgiyi @ drankin2112 tarafından ayrıntılı olarak açıklandığı gibi dönüştürmek için.

var inputTimestamp = "2014-04-29 13:00:15"; //example

var partsTimestamp = inputTimestamp.split(/[ \/:-]/g);
if(partsTimestamp.length < 6) {
    partsTimestamp = partsTimestamp.concat(['00', '00', '00'].slice(0, 6 - partsTimestamp.length));
}
//if your string-format is something like '7/02/2014'...
//use: var tstring = partsTimestamp.slice(0, 3).reverse().join('-');
var tstring = partsTimestamp.slice(0, 3).join('-');
tstring += 'T' + partsTimestamp.slice(3).join(':') + 'Z'; //configure as needed
var timestamp = Date.parse(tstring);

Tarayıcınız aşağıdakilerle aynı zaman damgası sonucunu sağlamalıdır Date.parse:

(new Date(tstring)).getTime()

Her ikisi de doğrudur, ancak iki farklı zaman dilimine sahip tarihler olarak yorumlanmaktadır. Elmaları ve portakalları karşılaştırdınız:

// local dates
new Date("Jul 8, 2005").toISOString()            // "2005-07-08T07:00:00.000Z"
new Date("2005-07-08T00:00-07:00").toISOString() // "2005-07-08T07:00:00.000Z"
// UTC dates
new Date("Jul 8, 2005 UTC").toISOString()        // "2005-07-08T00:00:00.000Z"
new Date("2005-07-08").toISOString()             // "2005-07-08T00:00:00.000Z"

Date.parse()Bir dize bağımsız değişkeninde otomatik olarak kullanıldığından aramayı kaldırdım . Tarihleri, yerel tarihler ve UTC tarihleri ​​arasındaki tarihleri ​​görsel olarak karşılaştırabilmeniz için ISO8601 biçimini kullanarak karşılaştırdım. Zamanlar 7 saat aralıklıdır, bu da saat dilimi farkıdır ve testlerinizin neden iki farklı tarih gösterdiği.

Aynı yerel / UTC tarihlerini oluşturmanın diğer yolu:

new Date(2005, 7-1, 8)           // "2005-07-08T07:00:00.000Z"
new Date(Date.UTC(2005, 7-1, 8)) // "2005-07-08T00:00:00.000Z"

Ama yine de basit ama güçlü olan Moment.js'yi şiddetle tavsiye ediyorum :

// parse string
moment("2005-07-08").format()       // "2005-07-08T00:00:00+02:00"
moment.utc("2005-07-08").format()   // "2005-07-08T00:00:00Z"
// year, month, day, etc.
moment([2005, 7-1, 8]).format()     // "2005-07-08T00:00:00+02:00"
moment.utc([2005, 7-1, 8]).format() // "2005-07-08T00:00:00Z"

CMS'den kabul cevap doğrudur, sadece bazı özellikler ekledik:

• giriş alanlarını kırp ve temizle
• eğik çizgi, tire, iki nokta üst üste ve boşlukları ayrıştırma
• varsayılan gün ve saati var

// parse a date time that can contains spaces, dashes, slashes, colons
function parseDate(input) {
    // trimes and remove multiple spaces and split by expected characters
    var parts = input.trim().replace(/ +(?= )/g,'').split(/[\s-\/:]/)
    // new Date(year, month [, day [, hours[, minutes[, seconds[, ms]]]]])
    return new Date(parts[0], parts[1]-1, parts[2] || 1, parts[3] || 0, parts[4] || 0, parts[5] || 0); // Note: months are 0-based
}