Moment.js'den JS Temporal API'ye Geçiş

JavaScript'te yazılan hemen hemen her tür uygulama, belirli bir kapasitede saat veya tarihlerle çalışır. Başlangıçta bu, yerleşik özelliklerle sınırlıydı.TarihAPI'dir. 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 sonraki yerleşik API'lerUluslararasıAPI'ler ve yeniGeçici API, saatler ve tarihlerle çalışmaya çok daha fazla esneklik katın.

Moment.jssaatler ve tarihlerle çalışmak için güçlü araçlara sahip bir JavaScript kitaplığıdır. Temelden eksik özellikleri içerirTarih API'sisaat dilimi manipülasyonu gibi birçok yaygın işlemi kolaylaştırır. 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ığı nesnelerindeğişken. 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.

Gibi başka JavaScript tarih kitaplıkları da vardır.tarih-fns, ancak şehirde yeni bir oyuncu var; doğrudan JavaScript'e yerleşik bir API:Zamansal. Orijinalin deliklerini dolduran yeni bir standartTarihAPI'nin yanı sıra Moment ve diğer kütüphanelerde bulunan bazı sınırlamaları da çözer.

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. Zaten birkaç tarayıcıda uygulanmıştır:Krom 144+VeFirefox 139+, ileSafari'nin yakında takip etmesi bekleniyor. Açoklu doldurma da mevcutturdesteklenmeyen tarayıcılar ve Node.js için.

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.
• Saat dilimi desteği.
  Zamansal nesneler tamamen zaman dilimi farkındadır ve farklı zaman dilimleri arasında dönüştürülebilir. Moment, zaman dilimlerini de destekler, ancak ekan-saat dilimikütüphane.
• 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 (ve Moment'teki) hataların yaygın bir kaynağı, ayların sıfır endeksli olmasıdır. Bu, Ocak ayı olduğu anlamına gelir0, ay yerine1hepimizin gerçek hayatta anladığı gibi. Geçici olarak 1 tabanlı indekslemeyi kullanarak bu sorunu düzeltiriz - Ocak ayıdır1.
• 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!

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çinanişlev.

ş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 zaman hakkında bilgi içermesidir.Vetarih. 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. Geçerli tarih ve saati temsil eden bir nesne oluşturabilirsiniz.Zamansal.Anlıknesne. 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

Zamansal.Anlıkkullanılarak belirli bir saat ve tarih için nesneler de oluşturulabilir.itibarenStatik yöntem.

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 - nesneyi aşağıdaki gibi değiştirmezmoment.utcyapmak.
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 bulunmadığı saat.
• Temporal.ZonedDateTime: Belirli bir saat dilimindeki tarih ve saat.

Bunların her birinin biritibarenTarih ve/veya saati belirten bir nesneyle veya ayrıştırılacak bir tarih dizesiyle çağrılabilen yöntem.

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

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, onu ileterek ayrıştırabilirsiniz.anişlev. 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-20262 Şubat mı 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,itibarenyöntemi, Temporal bir atacakAralık Hatası.

// 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,Zamansal.Anlıktarih ve saati saat dilimi farkıyla belirten tam bir ISO 8601 veya RFC 9557 tarih dizesi gerektirir, ancak aynı zamandaDüz TarihveyaDüz Zamantarih biçiminin yalnızca bir alt kümesini kullanan nesneler.

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 kullanma

Temporal güvenilirliğe öncelik verdiği için aşağıdaki gibi bir dizenin biçimini tahmin etmeye çalışmaz:02-01-2026. Veri kaynağınız bu tür dizeler kullanıyorsa, değerleri aşağıdaki gibi bir ISO dizesi halinde yeniden düzenlemek için bazı dize düzenlemeleri yapmanız gerekecektir:2026-02-01Temporal ile kullanmaya çalışmadan önce.

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. Nesneyi çağırırsınızbiçimİstenilen tarih biçimini tanımlayan bir dizi belirteç içeren yöntem.

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. Zamansal nesneler, örneğinAni, sahip olmaktoLocaleStringBir nesnenin özellikleri olarak belirtilen çeşitli biçimlendirme seçeneklerini kabul eden yöntem.

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ındaUluslararasıDateTimeFormatAPI'si(Modern tarayıcılarda zaten mevcut olan) başlık altında. Bu, yeniden kullanılabilir bir tane oluşturabileceğiniz anlamına gelirTarihSaatBiçimiözel biçimlendirme seçeneklerinizle nesneyi seçin, ardından Geçici nesneleri kendisine aktarınbiçimYöntem. Bu nedenle Moment'in yaptığı gibi özel tarih formatlarını desteklemez. Eğer böyle bir şeye ihtiyacın varsa'Q1 2026'veya diğer özel biçimlendirmelere ihtiyacınız varsa, bazı özel tarih biçimlendirme kodlarına ihtiyacınız olabilir veya üçüncü taraf bir kitaplığa ulaşabilirsiniz.

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

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 aşağıdaki gibi yöntemleri vardır:eklemekVeçıkarmabu işlemleri gerçekleştirenler. Bu işlevler bir değer ve bir birim alır; örneğin:add(7, 'günler'). 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 arayabilirsiniz.klonbir kopya oluşturmak için Moment nesnesinde.

şimdi const = moment();
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 nesnelerdeğişmez. gibi bir nesne oluşturduğunuzdaAni,Düz Tarihvb. gibi durumlarda o nesnenin değeri hiçbir zaman değişmeyecektir. Zamansal nesneler deeklemekVeçıkarmayöntemler.

Temporal, hangi nesne türlerine hangi zaman birimlerinin eklenebileceği konusunda biraz seçicidir. Örneğin, bir tarihe gün ekleyemezsiniz.Ani:

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 nedeniAninesneler UTC'de belirli bir zaman noktasını temsil eder ve takvimden bağımsızdır. Günün uzunluğu, Yaz Saati Uygulaması gibi saat dilimi kurallarına göre değişebileceğinden, bu hesaplama belirli bir tarihte yapılamaz.Ani. Senolabilmekancak bu işlemi diğer nesne türleri üzerinde de gerçekleştirebilirsiniz.DüzTarihSaat:

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 ilefarkişlevinde ayrıntı düzeyi için bir birim sağlamanız gerekir, aksi takdirde farkı milisaniye cinsinden döndürü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 ona aktarabilirsiniz.değinveyao zamandan beriyöntemler. Bu bir döndürürZamansal.Süresaat farkı hakkında bilgi içeren nesne.SüreNesne, farkın her bir bileşeni için özelliklere sahiptir ve aynı zamanda birISO8601zaman farkını temsil eden süre dizesi.

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)

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 aşağıdaki gibi yöntemler sağlar:isBefore,isAfter, Veaynıiki Moment nesnesini karşılaştırmak için.

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

Geçici bir statik kullanırkarşılaştırmakAynı türden iki nesne arasında karşılaştırma yapma yöntemi. Geri dönüyor-1ilk tarih ikinciden önce gelirse,0eğer eşitlerse veya1ilk randevu ikinciden sonra gelirse. Aşağıdaki örnek, ikisinin nasıl karşılaştırılacağını gösterirDüz Tarihnesneler. Her iki argüman daTemporal.PlainDate.compareolmalıdırDüz Tarihnesneler.

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

Çekirdek Moment kitaplığı, saat dilimi dönüşümlerini desteklemez. Bu işlevselliğe ihtiyacınız varsa, ayrıca yüklemeniz gerekir.an-saat dilimipaket. Bu paket sarsılmazdır ve bu nedenle paket boyutunuza önemli ölçüde katkıda bulunabilir. Kurulumu yaptıktan sonraan-saat dilimiile Moment nesnelerini farklı saat dilimlerine dönüştürebilirsiniz.tzYöntem. Diğer Moment işlemlerinde olduğu gibi, bu da temeldeki nesneyi değiştirir.

// 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 API'de yerleşik olarak bulunur.Temporal.ZonedDateTimenesne. Bu nesneler şunları içerir:TimeZone ileyeni bir değer döndüren yöntemBölgelendirilmişTarihSaatzamanda aynı anı temsil eder, ancak belirtilen saat dilimindedir.

// 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: Tarafından döndürülen biçimlendirilmiş değerlertoLocaleStringAdından da anlaşılacağı gibi yerel ayara bağlıdır. Örnek kod şu şekilde geliştirildi:tr-TRyerel ayar, yani format şöyle:28.02.2026 17:12:02 PST. Başka bir bölgede bu durum farklı olabilir. Örneğin,tr-GByerel ayar, şöyle bir şey elde edersiniz28/2/2026, 17:12:02 GMT-8.

Farklı saat dilimlerinde etkinlikleri planlamak için bir uygulama geliştirdiğimizi varsayalım. Bu uygulamanın bir kısmı bir işlevdir,getEventTimesOlayın saatini ve tarihini, yerel saat dilimini ve hedef saat dilimini temsil eden ISO 8601 dizesini alır. İş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ı zamandaan-saat dilimipaket).

'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 ilk anı oluşturun
  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 kullanarak biçimlendirme (yerleşik)
  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 şu şekilde biçimlendirilecektir:5 Mart 2026 15:00:00 EST.

Ayrıca açıkça bir istisna atmamıza da gerek yok. Geçersiz bir dize iletilirseGeçici.Anlık.başlangıç, Temporal bizim için istisnayı atacak. 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 şunu da unutmamalısınız ki, kullandığımız içingezgin.dil, bu kod yalnızca tarayıcı ortamında çalışacaktır, çünkügezginNode.js ortamında tanımlanmamıştır.

Geçici uygulama, tarayıcının geçerli yerel ayarını kullanır (gezgin.dil), böylece kullanıcı otomatik olarak etkinlik zamanlarını kendi yerel saat biçiminde biçimlendirecektir. içindetr-TRyerel ayar, burası5 Mart 2026 15:00:00 EST. Ancak kullanıcı örneğin Londra'daysa etkinlik saatleri şu şekilde biçimlendirilecektir:5 Mart 2026 15:00:00 GMT-5.

İ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ç temel avantajı vardır:

• Daha açık olmak demekdaha az sürpriz ve istenmeyen hata. 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 de kullanıyorsanız, uygulamanın paketine önemli bir boyut katabilir.an-saat dilimipaket. Temporal hiçbir şey eklemez (hedef tarayıcılarınıza gönderildikten sonra).
• Değişmezliktarih dönüştürmeleri ve işlemleri gerçekleştirirken hiçbir zaman verileri kaybetmeyeceğiniz veya verilerin üzerine yazmayacağınız konusunda size güven verir.
• Zamanın farklı temsilleri(Ani,DüzTarihSaat,BölgelendirilmişTarihSaat) gereksinimlerinize bağlı olarak; burada Moment her zaman bir UTC zaman damgasının etrafındaki sarmalayıcıdır.
• Geçici kullanımlarUluslararasıTarih biçimlendirmesine yönelik API'lerBu, belirteçleri açıkça belirtmenize gerek kalmadan yerel ayarlara duyarlı biçimlendirmeye sahip olabileceğiniz anlamına gelir.

Daha önce de belirtildiği gibi, adında bir npm paketi olarak dağıtılan bir Geçici çoklu doldurma mevcuttur.@js-temporal/polyfill. 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, hala önemli ölçüde daha az katkı sağlıyoranveyaan-saat dilimi. 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):

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.