JavaScript'te yazılan hemen hemen her tür uygulama, belirli bir kapasitede saat veya tarihlerle çalışır. Başlangıçta bu, yerleşik Date API ile sınırlıydı. Bu API temel işlevleri içerir ancak yapabilecekleri oldukça sınırlıdır. Moment.js gibi üçüncü taraf kitaplıklar ve daha sonra Intl API'ler ve yeni Temporal API gibi yerleşik API'ler, saat ve tarihlerle çalışmaya çok daha fazla esneklik katar. Moment.js'nin Yükselişi ve Düşüşü Moment.js, saatler ve tarihlerle çalışmak için güçlü araçlara sahip bir JavaScript kitaplığıdır. Temel Date API'sinde saat dilimi manipülasyonu gibi eksik olan özellikleri içerir ve birçok yaygın işlemi basitleştirir. Moment ayrıca tarihleri ve saatleri biçimlendirmeye yönelik işlevler de içerir. Birçok farklı uygulamada yaygın olarak kullanılan bir kütüphane haline geldi. Ancak Moment'in de sorunlardan payı vardı. Bu büyük bir kitaplıktır ve bir uygulamanın paket boyutunu önemli ölçüde artırabilir. Kitaplık, ağaç sallamayı (kitaplıkların kullanılmayan kısımlarını kaldırabilen modern paketleyicilerin bir özelliği) desteklemediğinden, yalnızca bir veya iki işlevinden yararlansanız bile Moment kitaplığının tamamı dahil edilir. Moment'in bir diğer sorunu da yarattığı nesnelerin değiştirilebilir olmasıdır. Bir Moment nesnesinde belirli işlevleri çağırmanın yan etkileri vardır ve o nesnenin değerini değiştirir. Bu beklenmedik davranışlara veya hatalara yol açabilir. 2020 yılında Moment'in geliştiricileri kütüphaneyi bakım moduna geçirmeye karar verdi. Hiçbir yeni özellik geliştirme yapılmıyor ve bakımcılar bunun yeni projelerde kullanılmamasını tavsiye ediyor. Date-fns gibi başka JavaScript tarih kitaplıkları da var, ancak artık yeni bir oyuncu var; doğrudan JavaScript'e yerleştirilmiş bir API: Temporal. Orijinal Date API'sindeki boşlukları dolduran ve aynı zamanda Moment ve diğer kitaplıklarda bulunan bazı sınırlamaları çözen yeni bir standarttır. Geçici Nedir? Temporal, modern JavaScript'i tanımlayan ECMAScript standardına eklenen yeni bir saat ve tarih API'sidir. Mart 20266 itibarıyla TC39 sürecinin (JavaScript diline yapılan teklifleri ve eklemeleri denetleyen komite) 4. Aşamasına ulaştı ve ECMAScript spesifikasyonunun bir sonraki sürümüne dahil edilecek. Halihazırda birçok tarayıcıda uygulandı: Chrome 144+ ve Firefox 139+; Safari'nin de yakında bunu takip etmesi bekleniyor. Desteklenmeyen tarayıcılar ve Node.js için çoklu doldurma da mevcuttur. Temporal API, genellikle zaman içindeki anları temsil eden nesneler oluşturur. Bunlar, belirli bir saat dilimindeki tam zamanlı ve tarih damgaları olabileceği gibi, herhangi bir saat dilimi veya tarih bilgisi olmaksızın "duvar saati" saatinin genel bir örneği de olabilir. Temporal'ın temel özelliklerinden bazıları şunlardır:
Tarihli veya tarihsiz zamanlar. Bir Temporal nesne, belirli bir tarihteki belirli bir zamanı veya herhangi bir tarih bilgisi olmadan bir saati temsil edebilir. Saat olmadan belirli bir tarih de temsil edilebilir. Zaman dilimi desteği. Geçici nesneler tamamen zaman diliminin farkındadır ve farklı zaman dilimleri arasında dönüştürülebilir. Moment, saat dilimlerini de destekler, ancak ek moment-saat dilimi kitaplığını gerektirir. Değişmezlik: Bir Temporal nesne oluşturulduktan sonra değiştirilemez. Zaman aritmetiği veya saat dilimi dönüşümleri, temeldeki nesneyi değiştirmez. Bunun yerine yeni bir Temporal nesne üretirler. 1 tabanlı indeksleme. Date API'deki (aynı zamanda Moment'teki) hataların yaygın bir kaynağı, ayların sıfır indeksli olmasıdır. Bu, gerçek hayatta hepimizin anladığı gibi Ocak ayının 1. ay yerine 0. ay olduğu anlamına gelir. Geçici olarak bu durum 1 tabanlı indeksleme kullanılarak düzeltilir; Ocak 1. aydır. Tarayıcının içine yerleşiktir. Temporal, tarayıcının kendisinde bulunan bir API olduğundan, uygulamanızın paket boyutuna hiçbir şey katmaz.
Date API'nin kaybolmayacağını da unutmamak gerekir. Temporal bu API'nin yerini alsa da kaldırılmıyor veya kullanımdan kaldırılmıyor. Tarayıcılar Date API'yi aniden kaldırırsa birçok uygulama bozulur. Ancak Moment'in artık bakım modunda eski bir proje olarak kabul edildiğini de unutmayın. Makalenin geri kalanında Moment tabanlı kodu yeni Temporal API'ye taşımak için bazı "tariflere" bakacağız. Yeniden düzenlemeye başlayalım! Tarih ve Saat Nesneleri Oluşturma Tarihleri ve saatleri değiştirmeden önce onları temsil eden nesneler yaratmamız gerekir. Geçerli tarih ve saati temsil eden bir Moment nesnesi oluşturmak için moment işlevini kullanın. şimdi const = moment(); console.log(şimdi); // An<2026-02-18T21:26:29-05:00>
Bu nesne artık gerektiği gibi biçimlendirilebilir veya değiştirilebilir.
// UTC'ye dönüştür //uyarı: Bu, Moment nesnesini değiştirir ve onu UTC moduna geçirir! console.log(now.utc()); // An<2026-02-19T02:26:29Z>
// biçimlendirilmiş bir dize yazdırın - şu anda UTC saatini kullandığını unutmayın console.log(now.format('AA/GG/YYYY ss:dd:ss a')); // 19.02.2026 02:27:07
Moment hakkında hatırlanması gereken en önemli şey, Moment nesnesinin her zaman saat ve tarih hakkında bilgi içermesidir. Yalnızca saat bilgileriyle çalışmanız gerekiyorsa bu genellikle iyidir ancak Yaz Saati Uygulaması veya artık yıllar gibi tarihin zaman hesaplamalarını etkileyebileceği durumlarda beklenmedik davranışlara neden olabilir. Zamansal daha esnektir. Temporal.Instant nesnesi oluşturarak geçerli tarih ve saati temsil eden bir nesne oluşturabilirsiniz. Bu, “dönemden” (1 Ocak 1970 gece yarısı UTC) bu yana geçen zaman tarafından tanımlanan bir zaman noktasını temsil eder. Temporal, zaman içindeki bu anı nanosaniye seviyesinde hassasiyetle referans alabilir. const şimdi = Temporal.Now.instant();
// çağdan bu yana ham nanosaniyeleri görün console.log(now.epochNanoseconds); // 1771466342612000000n
// UTC formatı console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// belirli bir saat diliminin biçimi console.log(now.toString({ timeZone: 'America/New_York' })); // 2026-02-18T20:56:57.905-05:00
Temporal.Instant nesneleri, from static yöntemi kullanılarak belirli bir saat ve tarih için de oluşturulabilir.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// An'ı yerel saat dilimine göre biçimlendirin. Bunun yalnızca kontrol ettiğini unutmayın // biçimlendirme - moment.utc'nin yaptığı gibi nesneyi değiştirmez. console.log(myInstant.toString({ timeZone: 'America/New_York' })); // 2026-02-18T21:10:00-05:00
Ayrıca aşağıdakiler de dahil olmak üzere başka türde Temporal nesneler de oluşturabilirsiniz:
Temporal.PlainDate: Saat bilgisi olmayan tarih. Temporal.PlainTime: Tarih bilgisinin olmadığı saat. Temporal.ZonedDateTime: Belirli bir saat dilimindeki tarih ve saat.
Bunların her biri, tarihi ve/veya saati belirten bir nesneyle veya ayrıştırılacak bir tarih dizesiyle çağrılabilen bir from yöntemine sahiptir. // Sadece bir tarih const bugün = Temporal.PlainDate.from({ yıl: 2026, ay: 2, // Şubat için 2 kullandığımızı unutmayın gün: 18 }); console.log(today.toString()); // 2026-02-18
// Sadece bir kez const öğle yemeğiZamanı = Temporal.PlainTime.from({ saat: 12 }); console.log(lunchTime.toString()); // 12:00:00
// ABD Doğu saat dilimindeki tarih ve saat const DueAt = Temporal.ZonedDateTime.from({ saat dilimi: 'Amerika/New_York', yıl: 2026, ay: 3, gün: 1, saat: 12, dakika: 0, saniye: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[Amerika/New_York]
Ayrıştırma Tarih ve saat bilgilerinin programlı olarak oluşturulmasını ele aldık. Şimdi ayrıştırmaya bakalım. Ayrıştırma, Moment'in yerleşik Temporal API'den daha esnek olduğu alanlardan biridir. Bir tarih dizesini moment işlevine ileterek ayrıştırabilirsiniz. Tek bir bağımsız değişkenle Moment, bir ISO tarih dizesi bekler, ancak kullanılan tarih biçimini belirten ikinci bir bağımsız değişken sağlarsanız alternatif biçimleri kullanabilirsiniz.
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = moment('21/26 9:00:00', 'A/G/YY s:dd:ss');
console.log(isoDate); // An<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // An<2026-02-21T09:00:00-05:00>
Eski sürümlerde Moment, rastgele biçimlendirilmiş herhangi bir tarih dizesini ayrıştırmak için en iyi tahminde bulunurdu. Bu öngörülemeyen sonuçlara yol açabilir. Örneğin, 02-03-2026 2 Şubat mı yoksa 3 Mart mı? Bu nedenle, Moment'in daha yeni sürümleri, ISO biçimli bir tarih dizesi olmadan çağrılırsa (istenen biçime sahip ikinci bağımsız değişken de verilmediği sürece) belirgin bir kullanımdan kaldırma uyarısı görüntüler. Temporal yalnızca özel olarak biçimlendirilmiş bir tarih dizesini ayrıştırır. Dize, ISO 8601 biçimiyle veya onun uzantısı olan RFC 9557 ile uyumlu olmalıdır. Uyumlu olmayan bir tarih dizesi, bir from yöntemine geçirilirse, Temporal bir RangeError oluşturur.
// RFC 9557 tarih dizesini kullanma const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[Amerika/New_York]'); console.log(myDate.toString({ timeZone: 'America/New_York' })); // 2026-02-21T09:00:00-05:00
// Bilinmeyen bir tarih dizisinin kullanılması const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Geçici hata: Yıl değeri ayrıştırılırken geçersiz karakter.
Tarih dizesinin tam gereksinimleri, oluşturduğunuz Temporal nesnenin türüne bağlıdır. Yukarıdaki örnekte Temporal.Instant tam bir ISO gerektirir.Tarih ve saati saat dilimi uzaklığıyla belirten 8601 veya RFC 9557 tarih dizesi, ancak tarih biçiminin yalnızca bir alt kümesini kullanarak PlainDate veya PlainTime nesneleri de oluşturabilirsiniz. const myDate = Temporal.PlainDate.from('2026-02-21'); console.log(myDate.toString()); // 2026-02-21
const myTime = Temporal.PlainTime.from('09:00:00'); console.log(myTime.toString()); // 09:00:00
Bu dizelerin yine de beklenen formata uyması gerektiğini, aksi takdirde bir hata oluşacağını unutmayın.
// Uyumlu olmayan bir zaman dizesi kullanma. Bunların hepsi bir RangeError atacak. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Profesyonel ipucu: ISO olmayan dizeleri işleme Temporal, güvenilirliğe öncelik verdiğinden, 02-01-2026 gibi bir dizenin biçimini tahmin etmeye çalışmaz. Veri kaynağınız bu tür dizeler kullanıyorsa, Temporal ile kullanmaya çalışmadan önce değerleri 2026-02-01 gibi bir ISO dizesinde yeniden düzenlemek için bazı dize işlemleri yapmanız gerekecektir.
Biçimlendirme Bir Moment veya Temporal nesnesine sahip olduğunuzda muhtemelen onu bir noktada biçimlendirilmiş bir dizeye dönüştürmek isteyeceksiniz. Bu, Moment'in biraz daha kısa olduğu bir örnektir. Nesnenin format yöntemini, istenen tarih formatını tanımlayan bir dizi belirteçle çağırırsınız. sabit tarih = an();
console.log(tarih.format('AA/GG/YYYY')); // 22/02/2026
console.log(date.format('MMMM Yap YYYY, s:dd:ss a')); // 22 Şubat 2026, 20:18:30
Öte yandan Temporal biraz daha ayrıntılı olmanızı gerektiriyor. Instant gibi geçici nesneler, bir nesnenin özellikleri olarak belirtilen çeşitli biçimlendirme seçeneklerini kabul eden bir toLocaleString yöntemine sahiptir.
const tarih = Temporal.Now.instant();
// hiçbir argüman olmadan, mevcut yerel ayar için varsayılan formatı alacağız console.log(date.toLocaleString()); // 22.02.2026, 20:23:36 (en-US yerel ayarı varsayılarak)
// özel bir biçim dizesi oluşturmak için biçimlendirme seçeneklerini iletin console.log(date.toLocaleString('en-US', { ay: 'uzun', gün: 'sayısal', yıl: 'sayısal', saat: '2 haneli', dakika: '2 haneli' })); // 22 Şubat 2026, 20:23
// yalnızca biçim dizesinde istediğiniz alanları iletin console.log(date.toLocaleString('en-US', { ay: 'kısa', gün: 'sayısal' })); // 22 Şubat
Geçici tarih biçimlendirmesi aslında Intl.DateTimeFormat API'sini (modern tarayıcılarda zaten mevcut olan) kullanır. Bu, özel biçimlendirme seçeneklerinizle yeniden kullanılabilir bir DateTimeFormat nesnesi oluşturabileceğiniz ve ardından Temporal nesneleri bu nesnenin biçimlendirme yöntemine aktarabileceğiniz anlamına gelir. Bu nedenle Moment'in yaptığı gibi özel tarih formatlarını desteklemez. 'Q1 2026' veya başka bir özel biçimlendirmeye ihtiyacınız varsa, bazı özel tarih biçimlendirme kodlarına veya üçüncü taraf bir kitaplığa erişmeniz gerekebilir. const formatlayıcı = new Intl.DateTimeFormat('en-US', { ay: '2 haneli', gün: '2 haneli', yıl: 'sayısal' });
const tarih = Temporal.Now.instant(); console.log(formatter.format(tarih)); // 22/02/2026
Moment'in biçimlendirme belirteçlerinin yazılması daha kolaydır ancak bunlar yerel ayar dostu değildir. Biçim, ay/gün sırası gibi "sabit kod" öğelerini dizer. Temporal'ın yaptığı gibi bir yapılandırma nesnesi kullanmanın avantajı, herhangi bir yerel ayara otomatik olarak uyum sağlaması ve doğru formatı kullanmasıdır. const tarih = Temporal.Now.instant();
const formatSeçenekler = { ay: 'sayısal', gün: 'sayısal', yıl: 'sayısal' };
console.log(date.toLocaleString('en-US', formatOptions)); // 22.02.2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22/02/2026
Tarih hesaplamaları Pek çok uygulamada, bir tarih üzerinde bazı hesaplamalar yapmanız gerekecektir. Zaman birimlerini (gün, saat, saniye vb.) eklemek veya çıkarmak isteyebilirsiniz. Örneğin güncel tarihiniz varsa kullanıcıya bundan 1 hafta sonraki tarihi göstermek isteyebilirsiniz. Moment nesnelerinin bu işlemleri gerçekleştiren toplama, çıkarma gibi yöntemleri vardır. Bu işlevler bir değer ve birim alır; örneğin: add(7, 'days'). Ancak Moment ve Temporal arasındaki çok önemli bir fark, bu tarih hesaplamaları yapılırken alttaki nesnenin değişmesi ve orijinal değerinin kaybolmasıdır. şimdi const = moment();
console.log(şimdi); // An<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'günler'); console.log(sonrakiHafta); // An<2026-03-03T20:08:36-05:00>
// Yakaladım - orijinal nesne mutasyona uğradı console.log(şimdi); // An<2026-03-03T20:08:36-05:00>
Orijinal tarihi kaybetmemek için bir kopya oluşturmak üzere Moment nesnesinde clone öğesini çağırabilirsiniz. şimdi oluştur= an(); const nextWeek = now.clone().add(7, 'günler');
console.log(şimdi); // An<2026-02-24T20:12:55-05:00>
console.log(sonrakiHafta); // An<2026-03-03T20:12:55-05:00>
Öte yandan Zamansal nesneler değişmezdir. Instant, PlainDate vb. gibi bir nesne oluşturduğunuzda, o nesnenin değeri hiçbir zaman değişmeyecektir. Zamansal nesnelerin de toplama ve çıkarma yöntemleri vardır. Temporal, hangi nesne türlerine hangi zaman birimlerinin eklenebileceği konusunda biraz seçicidir. Örneğin, bir Anında Arama'ya gün ekleyemezsiniz:
const şimdi = Temporal.Now.instant(); const nextWeek = now.add({ gün: 7 }); // RangeError: Geçici hata: En büyük birim tarih birimi olamaz
Bunun nedeni, Anında nesnelerin UTC'de belirli bir zaman noktasını temsil etmesi ve takvimden bağımsız olmasıdır. Bir günün uzunluğu, Yaz Saati Uygulaması gibi saat dilimi kurallarına göre değişebileceğinden, bu hesaplama Anında Yapılamaz. Ancak bu işlemi PlainDateTime gibi diğer nesne türlerinde de gerçekleştirebilirsiniz: const şimdi = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 24.02.2026, 20:23:59
const nextWeek = now.add({ gün: 7 });
// Orijinal PlainDateTime'ın değişmeden kaldığını unutmayın console.log(now.toLocaleString()); // 24.02.2026, 20:23:59
console.log(nextWeek.toLocaleString()); // 3/3/2026, 20:23:59
Ayrıca iki Moment veya Temporal nesne arasında ne kadar süre olduğunu da hesaplayabilirsiniz. Moment'in diff işleviyle, ayrıntı düzeyi için bir birim sağlamanız gerekir, aksi takdirde fark milisaniye cinsinden döndürülür. const tarih1 = moment('2026-02-21T09:00:00'); const tarih2 = moment('2026-02-22T10:30:00');
console.log(tarih2.diff(tarih1)); // 91800000
console.log(tarih2.diff(tarih1, 'günler')); // 1
Bunu bir Temporal nesneyle yapmak için, başka bir Temporal nesneyi onun kadar veya beri yöntemlerine aktarabilirsiniz. Bu, saat farkıyla ilgili bilgileri içeren bir Temporal.Duration nesnesini döndürür. Süre nesnesi, farkın her bileşeni için özelliklere sahiptir ve ayrıca zaman farkını temsil eden bir ISO 8601 süre dizesi oluşturabilir.
const tarih1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const tarih2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// en büyükBirim temsil edilecek en büyük zaman birimini belirtir // süre hesaplamasında const diff = tarih2.since(tarih1, { en büyükBirim: 'gün' });
console.log(fark.günler); // 1
console.log(diff.saatler); // 1
console.log(diff.dakikalar); // 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 süre dizisi: 1 gün, 1 saat, 30 dakika)
Tarihleri ve Saatleri Karşılaştırma Moment ve Temporal, hangisinin diğerinden önce geldiğini belirlemek için tarihleri ve saatleri karşılaştırmanıza olanak tanır, ancak API ile farklı yaklaşımlar benimser. Moment, iki Moment nesnesini karşılaştırmak için isBefore, isAfter ve isSame gibi yöntemler sağlar. const tarih1 = moment('2026-02-21T09:00:00'); const tarih2 = moment('2026-02-22T10:30:00');
console.log(tarih1.isBefore(tarih2)); // doğru
Temporal, aynı türden iki nesne arasında karşılaştırma yapmak için statik bir karşılaştırma yöntemi kullanır. İlk tarih ikinciden önce gelirse -1, eşitse 0, ilk tarih ikinciden sonra gelirse 1 değerini döndürür. Aşağıdaki örnek, iki PlainDate nesnesinin nasıl karşılaştırılacağını gösterir. Temporal.PlainDate.compare argümanlarının her ikisi de PlainDate nesneleri olmalıdır.
const date1 = Temporal.PlainDate.from({ yıl: 2026, ay: 2, gün: 24 }); const date2 = Temporal.PlainDate.from({ yıl: 2026, ay: 3, gün: 24 });
// tarih1 tarih2'den önce gelir, yani -1 console.log(Temporal.PlainDate.compare(tarih1, tarih2));
// Farklı türdeki iki nesneyi karşılaştırmaya çalıştığımızda hata oluştu console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // TypeError: Geçici hata: Geçersiz PlainDate alanları sağlandı.
Özellikle bu, bir dizi Zamansal nesneyi kronolojik olarak sıralamayı kolaylaştırır. // Temporal.PlainDate nesnelerinin bir dizisi sabit tarihler = [ ... ];
// karşılaştırıcı işlevi olarak Temporal.PlainDate.compare'ı kullanın date.sort(Temporal.PlainDate.compare);
Saat Dilimi Dönüşümleri Çekirdek Moment kitaplığı, saat dilimi dönüşümlerini desteklemez. Bu işlevselliğe ihtiyacınız varsa moment-timezone paketini de yüklemeniz gerekir. Bu paket sarsılmazdır ve bu nedenle paket boyutunuza önemli ölçüde katkıda bulunabilir. Moment-timezone'u yükledikten sonra Moment nesnelerini tz yöntemiyle farklı zaman dilimlerine dönüştürebilirsiniz. Diğer Moment işlemlerinde olduğu gibi, bu da temeldeki işlemi değiştirir.nesne. // ABD Doğu saatini varsayarsak şimdi const = moment(); console.log(şimdi); // An<2026-02-28T20:08:20-05:00>
// Pasifik saatine dönüştürün. // Orijinal Doğu saati kayboldu. now.tz('Amerika/Los_Angeles'); console.log(şimdi); // An<2026-02-28T17:08:20-08:00>
Saat dilimi işlevi, Temporal.ZonedDateTime nesnesi kullanıldığında Temporal API'ye yerleşiktir. Bu nesneler, zamanda aynı anı ancak belirtilen saat diliminde temsil eden yeni bir ZonedDateTime döndüren withTimeZone yöntemini içerir. // Yine ABD Doğu saatini varsayarsak const şimdi = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 28.02.2026, 20:12:02 EST
// Pasifik saatine dönüştür const nowPacific = now.withTimeZone('Amerika/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 28.02.2026 17:12:02 PST
// Orijinal nesne değişmeden kalır console.log(now.toLocaleString()); // 28.02.2026, 20:12:02 EST
Not: toLocaleString tarafından döndürülen biçimlendirilmiş değerler, adından da anlaşılacağı gibi yerel ayara bağlıdır. Örnek kod en-US yerel ayarında geliştirildi, dolayısıyla format şu şekildedir: 28.02.2026, 17:12:02 PST. Başka bir bölgede bu durum farklı olabilir. Örneğin, en-GB yerel ayarında 28/2/2026, 17:12:02 GMT-8 gibi bir şey elde edersiniz. Gerçek Dünyada Yeniden Düzenleme Farklı saat dilimlerinde etkinlikleri planlamak için bir uygulama geliştirdiğimizi varsayalım. Bu uygulamanın bir kısmı, olayın saatini ve tarihini, yerel saat dilimini ve hedef saat dilimini temsil eden ISO 8601 dizesini alan getEventTimes işlevidir. İşlev, her iki saat dilimindeki olay için biçimlendirilmiş saat ve tarih dizeleri oluşturur. İşleve geçerli bir saat/tarih dizesi olmayan bir giriş dizesi verilirse hata verecektir. İşte Moment'i kullanan orijinal uygulama (aynı zamanda moment-timezone paketinin kullanılmasını da gerektirir).
'an-saat dilimi'nden anı içe aktar;
function getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, YYYY, s:dd:ss a z';
// 1. Kullanıcının saat diliminde başlangıç anını yaratın const olayZamanı = moment.tz( girişDizesi, moment.ISO_8601, // ISO 8601 dizesini bekliyoruz true, // Kesin ayrıştırma kullanıcıTimeZone );
// inputString geçerli bir tarihi temsil etmiyorsa bir hata atın if (!eventTime.isValid()) { throw new Error('Geçersiz tarih/saat girişi'); }
// 2. Hedef süreyi hesaplayın // KRİTİK: Klonlamalıyız, yoksa 'eventTime' sonsuza kadar değişir! const targetTime = eventTime.clone().tz(targetTimeZone);
dönüş { yerel: eventTime.format(timeFormat), hedef: targetTime.format(timeFormat), }; }
const zamanlama = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', 'Avrupa/Londra', );
console.log(schedule.local); // 5 Mart 2026, 15:00:00 EST
console.log(schedule.target); // 5 Mart 2026, 20:00:00 GMT
Bu örnekte, Moment'te yararlı bir şekilde yerleşik olarak bulunan ISO 8601'in beklenen tarih biçimini kullanıyoruz. Ayrıca katı ayrıştırma kullanıyoruz; bu, Moment'in formatla eşleşmeyen bir tarih dizesiyle tahmin etmeye çalışmayacağı anlamına gelir. ISO dışı bir tarih dizisi iletilirse, bu geçersiz bir tarih nesnesine neden olur ve hata veririz. Geçici uygulama benzer görünüyor ancak birkaç önemli farklılığı var.
function getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Girişi doğrudan bir Anında ayrıştırın, ardından oluşturun // kullanıcının bölgesinde bir ZonedDateTime. const anlık = Temporal.Instant.from(inputString); const eventTime = Instant.toZonedDateTimeISO(userTimeZone);
// 2. Hedef bölgeye dönüştürün // Bu otomatik olarak YENİ bir nesne döndürür; 'eventTime' güvenlidir. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Intl (yerleşik) kullanarak biçimlendirin sabit seçenekler = { yıl: 'sayısal', ay: 'kısa', gün: 'sayısal', saat: 'sayısal', dakika: '2 haneli', ikinci: '2 haneli', saat dilimi adı: 'kısa' };
dönüş { yerel: eventTime.toLocaleString(navigator.language, seçenekler), hedef: targetTime.toLocaleString(navigator.language, seçenekler) }; }
const zamanlama = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', 'Avrupa/Londra', );
console.log(schedule.local); // 5 Mart 2026, 15:00:00 EST
console.log(schedule.target); // 5 Mart 2026, 20:00:00 GMT
Moment ile, ortaya çıkan tarih dizeleri için açıkça bir biçim dizesi belirtmemiz gerekiyor. Kullanıcının konumu veya yerel ayarı ne olursa olsun etkinlik saatleri her zaman 5 Mart 2026, 3:00:00 olarak biçimlendirilecektir.öğleden sonra EST. Ayrıca açıkça bir istisna atmamıza da gerek yok. Temporal.Instant.from'a geçersiz bir dize iletilirse, Temporal bizim için istisnayı atar. Dikkat edilmesi gereken bir nokta, katı ayrıştırmayla bile Moment sürümünün hala daha hoşgörülü olmasıdır. Temporal, dizenin sonunda saat dilimi uzaklığını gerektirir. Ayrıca navigator.language kullandığımız için, navigator Node.js ortamında tanımlanmadığından bu kodun yalnızca tarayıcı ortamında çalışacağını da unutmayın. Geçici uygulama, tarayıcının geçerli yerel ayarını (navigator.language) kullanır, böylece kullanıcı, olay zamanlarını otomatik olarak kendi yerel saat biçiminde biçimlendirir. ABD yerel ayarında bu, 5 Mart 2026, 15:00:00 EST'dir. Ancak, örneğin kullanıcı Londra'daysa etkinlik saatleri 5 Mart 2026, 15:00:00 GMT-5 olarak biçimlendirilecektir. Özet
Eylem Moment.js Zamansal Geçerli saat an() Temporal.Now.zonedDateTimeISO() ISO ayrıştırılıyor an(str) Temporal.Instant.from(str) Zaman ekle .add(7, 'günler') (mutasyona uğrar) .add({ gün: 7 }) (yeni nesne) Fark .diff(diğer, 'saat') .since(other).hours Saat dilimi .tz('Bölge/Ad') .withTimeZone('Bölge/Ad')
İlk bakışta, sözdizimi biraz farklı olabilir (ve Temporal söz konusu olduğunda, bazen daha ayrıntılı ve daha katı olabilir), ancak Temporal kullanmanın Moment.js'ye göre birkaç önemli avantajı vardır:
Daha açık olmak, daha az sürpriz ve istenmeyen hata anlamına gelir. An daha hoşgörülü görünebilir, ancak bazen yanlış tarihlerle sonuçlanabilecek "tahmin" içerir. Temporal'a geçersiz bir şey verirseniz hata verir. Kod çalışırsa geçerli bir randevunuz olduğunu bilirsiniz. Moment, özellikle moment-timezone paketini kullanıyorsanız, uygulamanın paketine önemli bir boyut katabilir. Temporal hiçbir şey eklemez (hedef tarayıcılarınıza gönderildikten sonra). Değişmezlik, tarih dönüştürmeleri ve işlemleri gerçekleştirirken hiçbir zaman verileri kaybetmeyeceğiniz veya verilerin üzerine yazmayacağınıza dair güven verir. Gereksinimlerinize bağlı olarak farklı zaman gösterimleri (Instant, PlainDateTime, ZonedDateTime); burada Moment her zaman UTC zaman damgasını çevreleyen bir sarmalayıcıdır. Temporal, tarih biçimlendirmesi için Intl API'lerini kullanır; bu, belirteçleri açıkça belirtmenize gerek kalmadan yerel ayarlara duyarlı biçimlendirmeye sahip olabileceğiniz anlamına gelir.
Polyfill Üzerine Notlar Daha önce de belirtildiği gibi, @js-temporal/polyfill adında bir npm paketi olarak dağıtılan bir Temporal polyfill mevcuttur. Temporal'ı bugün kullanmak istiyorsanız Safari gibi henüz API'yi göndermemiş tarayıcıları desteklemek için bu çoklu doldurmaya ihtiyacınız olacak. Bununla ilgili kötü haber, paket boyutunuza eklenecek olmasıdır. İyi haber şu ki, an veya an-saat diliminden önemli ölçüde daha azını ekliyor. Burada, npm paket boyutları hakkında bilgi sunan bir web sitesi olan Bundlephobia.com tarafından bildirilen paket boyutlarının bir karşılaştırması bulunmaktadır (Bundlephobia analizini görmek için her bir paket adına tıklayın):
Paket Küçültülmüş Küçültülmüş ve gzip'le sıkıştırılmış @js-temporal/polyfill 154,1 kB 44,1 kB an 294,4 kB 75,4 kB an-saat dilimi 1 MB 114,2 kB
Polyfill'in ayrıca tarihsel olarak bellek kullanımıyla ilgili bazı performans sorunları vardı ve bu yazının yazıldığı sırada alfa durumunda olduğu düşünülüyordu. Bu nedenle daha olgun bir duruma gelinceye kadar üretimde kullanmak istemeyebilirsiniz. Diğer iyi haber ise, umarım çoklu doldurmaya daha uzun süre ihtiyaç duyulmaz (tabii ki eski tarayıcıları desteklemeniz gerekmiyorsa). Bu yazının yazıldığı sırada Temporal, Chrome, Edge ve Firefox'ta piyasaya sürüldü. Henüz Safari'de tam olarak hazır değil, ancak en son Teknoloji Önizlemesinde bir çalışma zamanı bayrağıyla mevcut olduğu görülüyor.
