M

MLOG

Türkçe

JavaScript Temporal API'sine dair bu kapsamlı rehber, uluslararası düzeyde tarih ve saatleri etkin bir şekilde yönetmek için modern bir çözüm sunar.

JavaScript Temporal API: Küresel Kitleler İçin Modern Tarih ve Saat Yönetimi

JavaScript'in `Date` nesnesi, geliştiriciler için uzun süredir bir hayal kırıklığı kaynağı olmuştur. Değiştirilebilirliği, tutarsız API'si ve zayıf saat dilimi desteği, boşlukları doldurmak için Moment.js ve date-fns gibi çok sayıda kütüphanenin ortaya çıkmasına neden olmuştur. Şimdi ise Temporal API ile JavaScript, tarih ve saatleri daha anlaşılır ve hassas bir şekilde yönetmek için modern, yerleşik bir çözüm sunuyor. Bu makale, Temporal API'nin özelliklerine, faydalarına ve çeşitli uluslararası bağlamlardaki kullanımına odaklanarak kapsamlı bir genel bakış sunmaktadır.

Temporal API Nedir?

Temporal API, JavaScript'te `Date` nesnesinin eksikliklerini gidermek için tasarlanmış yeni, küresel bir nesnedir. Tarihler, saatler, saat dilimleri ve takvim sistemleriyle çalışmak için temiz, değiştirilemez bir API sağlar. En önemlisi, tarih ve saat kavramlarını gerçek dünya kullanımına ve beklentilerine daha yakın bir şekilde temsil etmeyi amaçlayarak uluslararasılaştırmayı çok daha basit hale getirir.

Temel Özellikler:

Temel Temporal Nesneleri

Temporal API, birkaç yeni nesne türü sunar. İşte temel olanlardan bazıları:

Tarihlerle Çalışmak

`Temporal.PlainDate` Oluşturma

Bir `Temporal.PlainDate` oluşturmak için kurucu (constructor) metodu kullanabilirsiniz:

const plainDate = new Temporal.PlainDate(2024, 10, 27); // Yıl, Ay (1-12), Gün
console.log(plainDate.toString()); // Çıktı: 2024-10-27

Ayrıca, ISO 8601 formatında bir dize kabul eden `from` metodunu da kullanabilirsiniz:

const plainDateFromString = Temporal.PlainDate.from('2024-10-27');
console.log(plainDateFromString.toString()); // Çıktı: 2024-10-27

Tarih Bileşenlerini Alma

`year`, `month` ve `day` gibi özellikleri kullanarak bireysel tarih bileşenlerine erişebilirsiniz:

console.log(plainDate.year); // Çıktı: 2024
console.log(plainDate.month); // Çıktı: 10
console.log(plainDate.day); // Çıktı: 27

Tarih Aritmetiği

Gün, hafta, ay veya yıl eklemek veya çıkarmak için `plus` ve `minus` metodlarını kullanın. Bu metodlar yeni bir `Temporal.PlainDate` nesnesi döndürür:

const nextWeek = plainDate.plus({ days: 7 });
console.log(nextWeek.toString()); // Çıktı: 2024-11-03

const lastMonth = plainDate.minus({ months: 1 });
console.log(lastMonth.toString()); // Çıktı: 2024-09-27

Tarihleri Karşılaştırma

Tarihleri `compare` metodunu kullanarak karşılaştırabilirsiniz:

const date1 = new Temporal.PlainDate(2024, 10, 27);
const date2 = new Temporal.PlainDate(2024, 11, 15);

console.log(Temporal.PlainDate.compare(date1, date2)); // Çıktı: -1 (date1, date2'den daha erken)

Saatlerle Çalışmak

`Temporal.PlainTime` Oluşturma

Bir `Temporal.PlainTime` oluşturmak için kurucu metodu kullanın:

const plainTime = new Temporal.PlainTime(10, 30, 0); // Saat, Dakika, Saniye
console.log(plainTime.toString()); // Çıktı: 10:30:00

Veya ISO 8601 saat dizesiyle `from` metodunu kullanın:

const plainTimeFromString = Temporal.PlainTime.from('10:30:00');
console.log(plainTimeFromString.toString()); // Çıktı: 10:30:00

Saat Bileşenlerini Alma

console.log(plainTime.hour); // Çıktı: 10
console.log(plainTime.minute); // Çıktı: 30
console.log(plainTime.second); // Çıktı: 0

Saat Aritmetiği

const later = plainTime.plus({ minutes: 15 });
console.log(later.toString()); // Çıktı: 10:45:00

Tarih ve Saati Birlikte Kullanma

`Temporal.PlainDateTime` Oluşturma

Bir `Temporal.PlainDateTime` nesnesini doğrudan veya bir `Temporal.PlainDate` ile bir `Temporal.PlainTime` nesnesini birleştirerek oluşturabilirsiniz:

const plainDateTime = new Temporal.PlainDateTime(2024, 10, 27, 10, 30, 0);
console.log(plainDateTime.toString()); // Çıktı: 2024-10-27T10:30:00

const date = new Temporal.PlainDate(2024, 10, 27);
const time = new Temporal.PlainTime(10, 30, 0);
const combinedDateTime = date.toPlainDateTime(time);
console.log(combinedDateTime.toString()); // Çıktı: 2024-10-27T10:30:00

Saat Dilimleri

Saat dilimlerini doğru bir şekilde yönetmek, farklı konumlardaki kullanıcılarla ilgilenen uygulamalar için çok önemlidir. Temporal API, `Temporal.ZonedDateTime` ve `Temporal.TimeZone` nesneleri aracılığıyla sağlam bir saat dilimi desteği sunar.

`Temporal.ZonedDateTime` Oluşturma

Bir `Temporal.ZonedDateTime` oluşturmak için bir `Temporal.PlainDateTime` ve bir saat dilimi tanımlayıcısına ihtiyacınız vardır. Saat dilimi tanımlayıcıları IANA saat dilimi veritabanına dayanır (örneğin, `America/Los_Angeles`, `Europe/London`, `Asia/Tokyo`).

const plainDateTime = new Temporal.PlainDateTime(2024, 10, 27, 10, 30, 0);
const timeZone = 'America/Los_Angeles';
const zonedDateTime = plainDateTime.toZonedDateTime(timeZone);
console.log(zonedDateTime.toString()); // Çıktı: 2024-10-27T10:30:00-07:00[America/Los_Angeles] (Ofset, yaz saati uygulaması kurallarına bağlı olacaktır)

Alternatif olarak, bir `Instant`'tan `Temporal.ZonedDateTime` oluşturun.

const instant = Temporal.Instant.fromEpochSeconds(1666866600); // Örnek zaman damgası
const zonedDateTimeFromInstant = instant.toZonedDateTimeISO(timeZone); // 'America/Los_Angeles' gibi bir saat dilimi
console.log(zonedDateTimeFromInstant.toString());

Saat Dilimleri Arasında Dönüşüm Yapma

Bir `Temporal.ZonedDateTime` nesnesini `withTimeZone` metodunu kullanarak farklı bir saat dilimine dönüştürebilirsiniz:

const newTimeZone = 'Europe/London';
const zonedDateTimeInLondon = zonedDateTime.withTimeZone(newTimeZone);
console.log(zonedDateTimeInLondon.toString()); // Çıktı: 2024-10-27T18:30:00+01:00[Europe/London]

Saat Dilimi Ofsetleriyle Çalışma

`Temporal.TimeZone` nesnesinin `getOffsetStringFor` metodu, belirli bir `Temporal.Instant` için ofset dizesini sağlar:

const timeZoneObject = new Temporal.TimeZone(timeZone);
const offsetString = timeZoneObject.getOffsetStringFor(zonedDateTime.toInstant());
console.log(offsetString); // Çıktı: -07:00 (Yaz saati uygulaması kurallarına bağlı olarak)

Doğru hesaplamalar için doğru IANA saat dilimi tanımlayıcılarını kullanmak esastır. Bu tanımlayıcılar, yaz saati uygulaması ve saat dilimi sınırlarındaki değişiklikleri yansıtmak için düzenli olarak korunur ve güncellenir.

Süreler (Durations)

`Temporal.Duration` nesnesi bir zaman aralığını temsil eder. Tarih ve saatlere ekleme veya çıkarma yapmak için kullanılabilir.

`Temporal.Duration` Oluşturma

Yılları, ayları, günleri, saatleri, dakikaları, saniyeleri, milisaniyeleri, mikrosaniyeleri ve nanosaniyeleri belirterek kurucu metodu kullanarak bir `Temporal.Duration` oluşturabilirsiniz:

const duration = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7, 8, 9); // Yıllar, Aylar, Günler, Saatler, Dakikalar, Saniyeler, Milisaniyeler, Mikrosaniyeler, Nanosaniyeler
console.log(duration.toString()); // Çıktı: P1Y2M3DT4H5M6.007008009S

Veya bir ISO 8601 süre dizesi kullanarak:

const durationFromString = Temporal.Duration.from('P1Y2M3DT4H5M6S');
console.log(durationFromString.toString()); // Çıktı: P1Y2M3DT4H5M6S

Tarih ve Saatlere Süre Ekleme

const plainDate = new Temporal.PlainDate(2024, 10, 27);
const duration = new Temporal.Duration(0, 0, 7); // 7 gün
const newDate = plainDate.plus(duration);
console.log(newDate.toString()); // Çıktı: 2024-11-03

Ay veya yıl içeren süreleri tarihlere eklemenin, bir aydaki veya yıldaki gün sayısı değişebileceğinden dikkatli bir değerlendirme gerektirdiğini unutmayın.

Takvim Sistemleri

Temporal API, Gregoryen takviminin ötesinde farklı takvim sistemlerini destekler. Bu, çeşitli kültürel bağlamlarda tarihleri yönetmesi gereken uygulamalar için çok önemlidir. Destek hala gelişmekte olsa da, gelecekteki genişleme için bir temel sağlar.

Alternatif Takvimleri Kullanma

Belirli bir takvimi kullanmak için, Temporal nesneleri oluştururken bunu belirtebilirsiniz:

const hebrewDate = new Temporal.PlainDate(5785, 1, 1, { calendar: 'hebrew' });
console.log(hebrewDate.toString()); // Belirli çıktı, uygulamaya ve biçimlendirmeye bağlı olarak değişebilir. Bu yazının yazıldığı tarih itibarıyla birçok ortamda polyfill gerektirir.

Önemli: Gregoryen olmayan takvimler için destek, polyfill'ler veya belirli tarayıcı/ortam desteği gerektirebilir. En son bilgiler için Temporal API belgelerini ve tarayıcı uyumluluk tablolarını kontrol edin.

Tarih ve Saatleri Biçimlendirme

Temporal API tarih ve saat manipülasyonuna odaklanırken, biçimlendirme genellikle Uluslararasılaştırma API'sinin bir parçası olan `Intl.DateTimeFormat` nesnesi tarafından gerçekleştirilir. Temporal nesneleri, `Intl.DateTimeFormat` ile sorunsuz bir şekilde çalışır.

`Intl.DateTimeFormat` Kullanımı

İşte bir `Temporal.PlainDate` nesnesini `Intl.DateTimeFormat` kullanarak nasıl biçimlendireceğiniz:

const plainDate = new Temporal.PlainDate(2024, 10, 27);
const formatter = new Intl.DateTimeFormat('en-US', { year: 'numeric', month: 'long', day: 'numeric' });
console.log(formatter.format(plainDate)); // Çıktı: October 27, 2024

const formatterGerman = new Intl.DateTimeFormat('de-DE', { year: 'numeric', month: 'long', day: 'numeric' });
console.log(formatterGerman.format(plainDate)); // Çıktı: 27. Oktober 2024

`Intl.DateTimeFormat`'ın ilk argümanı, biçimlendirme için kullanılacak dili ve bölgesel gelenekleri belirleyen yerel ayardır. Farklı yerel ayarlar (örneğin, 'en-US', 'de-DE', 'fr-FR', 'ja-JP') kullanmak farklı çıktı biçimleri üretir.

`Temporal.ZonedDateTime` Biçimlendirme

`Temporal.ZonedDateTime` biçimlendirmesi benzerdir, ancak çıktıya saat dilimi bilgilerini de ekleyebilirsiniz:

const plainDateTime = new Temporal.PlainDateTime(2024, 10, 27, 10, 30, 0);
const timeZone = 'America/Los_Angeles';
const zonedDateTime = plainDateTime.toZonedDateTime(timeZone);

const formatter = new Intl.DateTimeFormat('en-US', { year: 'numeric', month: 'long', day: 'numeric', hour: 'numeric', minute: 'numeric', timeZoneName: 'short' });
console.log(formatter.format(zonedDateTime)); // Çıktı: October 27, 2024, 10:30 AM PDT (Saat dilimi kısaltması yaz saati uygulaması kurallarına bağlıdır)

Uluslararasılaştırma İçin En İyi Uygulamalar

Küresel bir bağlamda tarih ve saatlerle çalışırken, aşağıdaki en iyi uygulamaları aklınızda bulundurun:

Temporal API ile Eski Date Nesnesinin Karşılaştırması

İşte Temporal API'nin eski `Date` nesnesine kıyasla temel farklarını ve avantajlarını vurgulayan bir tablo:

Özellik Eski `Date` Nesnesi Temporal API
Değişebilirlik Değişebilir (orijinal nesneyi değiştirir) Değişmez (yeni nesneler döndürür)
Saat Dilimi Desteği Sınırlı ve genellikle sorunlu IANA saat dilimi veritabanına dayalı, sağlam ve doğru
API Tutarsız ve kullanımı zor Anlaşılır, tutarlı ve sezgisel
Hassasiyet Milisaniye Nanosaniye
Takvim Sistemleri Gregoryen ile sınırlı Alternatif takvim sistemlerini destekler (gelişen destekle)
Uluslararasılaştırma Sağlam uluslararasılaştırma için harici kütüphaneler gerektirir Yerleşik destek ve `Intl.DateTimeFormat` ile sorunsuz entegrasyon

Tarayıcı Desteği ve Polyfill'ler

Nispeten yeni bir API olduğu için, Temporal API için tarayıcı desteği hala gelişmektedir. Hangi tarayıcıların ve ortamların bunu yerel olarak desteklediğini görmek için en son tarayıcı uyumluluk tablolarını (örneğin, MDN Web Docs'ta) kontrol edin. Eski tarayıcılar veya yerel desteği olmayan ortamlar için, Temporal API işlevselliğini sağlamak üzere polyfill'ler kullanabilirsiniz. Uygun seçenekleri bulmak için web'de "Temporal API polyfill" araması yapın.

Sonuç

JavaScript Temporal API, JavaScript'te tarih ve saatlerin yönetilmesinde önemli bir adımı temsil etmektedir. Değişmezliği, anlaşılır API'si, sağlam saat dilimi desteği ve takvim sistemi yetenekleri, onu çeşitli uluslararası bağlamlarda tarih ve saatlerle doğru ve güvenilir bir şekilde çalışması gereken uygulamalar geliştiren geliştiriciler için güçlü bir araç haline getirir. Tarayıcı desteği hala gelişmekte olsa da, Temporal API'nin faydaları onu öğrenmeye ve yeni projeler için benimsemeye değer kılmaktadır. Temporal API'yi benimseyerek ve uluslararasılaştırma için en iyi uygulamaları takip ederek, dünya çapındaki kullanıcılar için sorunsuz ve doğru bir tarih ve saat deneyimi sağlayan uygulamalar oluşturabilirsiniz.

Daha Fazla Bilgi