JavaScript Temporal Duration: Zaman Aralığı Hesaplamalarında Uzmanlaşma

JavaScript'in Temporal API'si, tarihleri, saatleri ve zaman aralıklarını yönetmek için modern ve güçlü bir yol sunar. Temporal.Duration nesnesi, bir zaman uzunluğunu temsil ederek zaman aralıklarıyla hesaplamalar yapmak için açık ve sezgisel bir yaklaşım sağlar. Bu makale, Temporal.Duration nesnesinin ayrıntılarına inerek çeşitli kullanım durumları için sürelerin nasıl oluşturulacağını, değiştirileceğini ve biçimlendirileceğini göstermektedir.

Temporal.Duration Nedir?

Temporal.Duration, bir zaman aralığını temsil eder ve bunu yıllar, aylar, günler, saatler, dakikalar, saniyeler ve saniyenin kesirleri (milisaniye, mikrosaniye, nanosaniye) cinsinden ifade eder. Belirli bir zaman noktasını temsil eden Date nesnelerinin aksine, Temporal.Duration bir zaman miktarını temsil eder. ISO 8601 süre formatına (örneğin, P1Y2M10DT2H30M 1 yıl, 2 ay, 10 gün, 2 saat ve 30 dakikayı temsil eder) uyar. Temporal API, eski Date nesnesinden daha sezgisel ve daha az hataya açık olacak şekilde tasarlanmıştır.

Temporal.Duration Nesneleri Oluşturma

Temporal.Duration nesneleri oluşturmanın birkaç yolu vardır:

1. Yalın Bir Nesneden (From a Plain Object)

İstenen özelliklere sahip bir nesne geçirerek bir süre oluşturabilirsiniz:

const duration = new Temporal.Duration(1, 2, 10, 2, 30, 0, 0, 0);
console.log(duration.toString()); // Çıktı: P1Y2M10DT2H30M

Bu, 1 yıl, 2 ay, 10 gün, 2 saat ve 30 dakikalık bir süre oluşturur. Argümanların şu sıraya karşılık geldiğini unutmayın: yıllar, aylar, haftalar, günler, saatler, dakikalar, saniyeler, milisaniyeler, mikrosaniyeler, nanosaniyeler.

2. ISO 8601 String'inden

Ayrıca Temporal.Duration.from() kullanarak bir ISO 8601 süre string'inden bir süre oluşturabilirsiniz:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
console.log(duration.toString()); // Çıktı: P1Y2M10DT2H30M

Bu, özellikle string formatında saklanan veya harici bir kaynaktan alınan sürelerle uğraşırken kullanışlıdır.

3. Temporal.Instant, Temporal.ZonedDateTime vb. ile add() ve subtract() metodlarını kullanma

Temporal.Duration'ı diğer Temporal türlerinden (Temporal.Instant veya Temporal.ZonedDateTime gibi) eklediğinizde veya çıkardığınızda, ardından bu iki zaman noktasını birbirinden çıkarırsanız aradaki farkı temsil eden bir Temporal.Duration döndürülür. Örneğin:

const now = Temporal.Now.zonedDateTimeISO();
const later = now.add({ hours: 5 });
const duration = later.since(now);
console.log(duration.toString()); // Çıktı: PT5H

Süre Bileşenlerine Erişme

Bir Temporal.Duration nesnesinin bireysel bileşenlerine özelliklerini kullanarak erişebilirsiniz:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
console.log(duration.years);      // Çıktı: 1
console.log(duration.months);     // Çıktı: 2
console.log(duration.days);       // Çıktı: 10
console.log(duration.hours);      // Çıktı: 2
console.log(duration.minutes);     // Çıktı: 30
console.log(duration.seconds);     // Çıktı: 0
console.log(duration.milliseconds); // Çıktı: 0
console.log(duration.microseconds); // Çıktı: 0
console.log(duration.nanoseconds);  // Çıktı: 0

Sürelerle Aritmetik İşlemler Yapma

Temporal.Duration nesneleri, add() ve subtract() metodlarını kullanarak toplama ve çıkarma işlemlerini destekler. Bu metodlar, işlemin sonucunu temsil eden yeni bir Temporal.Duration nesnesi döndürür.

const duration1 = Temporal.Duration.from("P1Y2M");
const duration2 = Temporal.Duration.from("P3M4D");

const addedDuration = duration1.add(duration2);
console.log(addedDuration.toString()); // Çıktı: P1Y5M4D

const subtractedDuration = duration1.subtract(duration2);
console.log(subtractedDuration.toString()); // Çıktı: P10M26D

Daha karmaşık hesaplamalar için bu metodları zincirleyebilirsiniz:

const duration = Temporal.Duration.from("P1D").add({ hours: 12 }).subtract({ minutes: 30 });
console.log(duration.toString()); // Çıktı: P1DT11H30M

negated() metodu, tüm bileşenleri negatife çevrilmiş yeni bir Temporal.Duration nesnesi döndürür:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const negatedDuration = duration.negated();
console.log(negatedDuration.toString()); // Çıktı: -P1Y2M10DT2H30M

abs() metodu, tüm bileşenleri pozitif değerler (mutlak değerler) olarak içeren yeni bir Temporal.Duration nesnesi döndürür:

const duration = Temporal.Duration.from("-P1Y2M10DT2H30M");
const absoluteDuration = duration.abs();
console.log(absoluteDuration.toString()); // Çıktı: P1Y2M10DT2H30M

with() metodu, bazı veya tüm özelliklerin yeni değerlere değiştirildiği yeni bir Temporal.Duration örneği oluşturmanıza olanak tanır. Argüman nesnesinde bir değer belirtilmezse, sürenin orijinal değeri kullanılır. Örneğin:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const newDuration = duration.with({ years: 2, days: 5 });
console.log(newDuration.toString()); // Çıktı: P2Y2M5DT2H30M

Süreleri Normalleştirme

Süreler bazen normalleştirilmemiş bir biçimde ifade edilebilir (örneğin, P2Y'ye basitleştirilebilecek P1Y12M). normalized() metodu, bir süreyi en kompakt biçimine basitleştirmeye çalışır. Ancak, değişen ay uzunluklarının karmaşıklıklarını ele almak için bir referans tarihi gerektirir. Düzgün bir şekilde normalleştirmek için bir Temporal.PlainDate, Temporal.ZonedDateTime veya Temporal.Instant örneğine ihtiyacınız olacaktır.

Örneğin, ayları ve günleri içeren bir süreyi normalleştirmek bir referans tarihi gerektirir:

const duration = Temporal.Duration.from("P1M32D");
const referenceDate = Temporal.PlainDate.from("2024-01-01");
const normalizedDuration = duration.normalized({ relativeTo: referenceDate });
console.log(normalizedDuration.toString()); // Çıktı: P2M1D

Bu örnekte, P1M32D süresi 1 Ocak 2024'e göre normalleştirilir ve Ocak ayı 31 gün olduğu için sonuç P2M1D olur.

Eğer sadece zaman bileşenleriyle (saat, dakika, saniye vb.) uğraşıyorsanız, referans tarihi olmadan normalleştirme yapabilirsiniz:

const duration = Temporal.Duration.from("PT25H61M");
const normalizedDuration = duration.normalized({ relativeTo: null }); //veya relativeTo argümanını atlayın
console.log(normalizedDuration.toString()); // Çıktı: P1DT2H1M

Süreleri Karşılaştırma

compare() metodunu kullanarak süreleri karşılaştırabilirsiniz. Bu metod şunları döndürür:

• -1, eğer ilk süre ikinci süreden kısaysa.
• 0, eğer süreler eşitse.
• 1, eğer ilk süre ikinci süreden uzunsa.

const duration1 = Temporal.Duration.from("P1Y");
const duration2 = Temporal.Duration.from("P6M");

const comparisonResult = Temporal.Duration.compare(duration1, duration2);
console.log(comparisonResult); // Çıktı: 1

Pratik Örnekler

1. Bir Etkinliğe Kalan Süreyi Hesaplama

Belirli bir etkinliğe kalan süreyi hesaplamak istediğinizi varsayalım. Mevcut zamanı almak için Temporal.Now.zonedDateTimeISO() kullanabilir ve etkinliğin tarihini çıkarabilirsiniz. Etkinliğin tarihi geçtiyse, çıktı negatif olacaktır.

const eventDate = Temporal.ZonedDateTime.from({ timeZone: 'America/Los_Angeles', year: 2024, month: 12, day: 25, hour: 9, minute: 0, second: 0 });
const now = Temporal.Now.zonedDateTimeISO('America/Los_Angeles');

const durationUntilEvent = eventDate.since(now);

console.log(durationUntilEvent.toString()); // Çıktı: örn., P262DT14H30M (mevcut tarih ve saate bağlı olarak)

2. Proje Görev Sürelerini Takip Etme

Proje yönetiminde, görevlerin tahmini veya gerçek süresini izlemek için Temporal.Duration'ı kullanabilirsiniz.

const task1EstimatedDuration = Temporal.Duration.from("PT8H"); // 8 saat
const task2EstimatedDuration = Temporal.Duration.from("PT16H"); // 16 saat

const totalEstimatedDuration = task1EstimatedDuration.add(task2EstimatedDuration);
console.log(`Toplam tahmini süre: ${totalEstimatedDuration.toString()}`); // Çıktı: Toplam tahmini süre: P1DT

3. Yaş Hesaplama

Yaşı hassas bir şekilde hesaplamak artık yılları ve saat dilimlerini dikkate almayı gerektirse de, Temporal.Duration makul bir tahmin sağlayabilir:

const birthDate = Temporal.PlainDate.from("1990-05-15");
const currentDate = Temporal.PlainDate.from("2024-01-20");

const ageDuration = currentDate.since(birthDate, { smallestUnit: 'years' });
console.log(`Tahmini yaş: ${ageDuration.years} yıl`); // Çıktı: Tahmini yaş: 33 yıl

4. İnsanların Okuyabileceği Süreleri Görüntüleme

Genellikle, süreleri insanlar tarafından okunabilir bir formatta görüntülemeniz gerekir. Temporal.Duration'ın yerleşik biçimlendirme işlevleri olmasa da, özel biçimlendirme mantığı oluşturabilirsiniz:

function formatDuration(duration) {
  const parts = [];
  if (duration.years) parts.push(`${duration.years} yıl`);
  if (duration.months) parts.push(`${duration.months} ay`);
  if (duration.days) parts.push(`${duration.days} gün`);
  if (duration.hours) parts.push(`${duration.hours} saat`);
  if (duration.minutes) parts.push(`${duration.minutes} dakika`);
  if (duration.seconds) parts.push(`${duration.seconds} saniye`);

  return parts.join(', ');
}

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const formattedDuration = formatDuration(duration);
console.log(formattedDuration); // Çıktı: 1 yıl, 2 ay, 10 gün, 2 saat, 30 dakika

Gelişmiş Kullanım ve Dikkat Edilmesi Gerekenler

1. Saat Dilimi Yönetimi

Saat dilimi sınırlarını veya yaz saati uygulaması geçişlerini aşan zaman aralıklarıyla uğraşırken, doğru hesaplamalar sağlamak için Temporal.ZonedDateTime kullanmak çok önemlidir. Temporal.PlainDate ve Temporal.PlainTime kullanmak, herhangi bir saat dilimi dönüşümünü önleyecektir.

2. En Küçük Birim ve Yuvarlama

since() ve until() metodları genellikle sonuçtaki süre için en küçük birimi tanımlamak üzere seçenekler kabul eder. Örneğin, bir etkinliğe *kalan* süreyi hesaplamak ve sonuçları günlere sınırlamak.

const eventDate = Temporal.PlainDate.from("2024-12-25");
const now = Temporal.PlainDate.from("2024-01-20");

const durationUntilEvent = now.until(eventDate, { smallestUnit: 'days' });

console.log(durationUntilEvent.toString()); //örnek çıktı PT340D

3. Artık Saniyeler

Temporal, artık saniyeleri doğal olarak hesaba katmaz. Aşırı hassasiyet gerektiriyorsanız, artık saniyeleri ayrı olarak ele almanız gerekecektir.

4. IANA Saat Dilimleri

Temporal API, IANA (Internet Assigned Numbers Authority) saat dilimi veritabanına dayanır. Saat dilimi dönüşümlerini doğru bir şekilde yönetmek için ortamınızda IANA veritabanının güncel bir sürümünün bulunduğundan emin olun.

En İyi Uygulamalar

• Süre string'leri için ISO 8601 formatını kullanın: Bu, tutarlılık ve birlikte çalışabilirlik sağlar.
• Uygun Temporal türünü seçin: Saat dilimi desteğine ihtiyacınız olup olmadığına bağlı olarak Temporal.PlainDate, Temporal.PlainTime, Temporal.ZonedDateTime veya Temporal.Instant kullanın.
• Gerektiğinde süreleri normalleştirin: Normalleştirme, süreleri basitleştirir ve karşılaştırılmalarını kolaylaştırır.
• Saat dilimlerini dikkatli bir şekilde yönetin: Saat dilimi dönüşümleri karmaşık olabilir, bu nedenle Temporal.ZonedDateTime kullanın ve yaz saati uygulaması geçişlerinin farkında olun.
• En küçük birimi göz önünde bulundurun: Süreleri hesaplarken, istenen hassasiyet seviyesini elde etmek için en küçük birimi belirtin.
• Birim testleri yazın: Süre hesaplamalarının doğru olduğundan emin olmak için kodunuzu kapsamlı bir şekilde test edin.

Yaygın Hatalar

• Saat dilimlerini görmezden gelmek: Saat dilimlerini hesaba katmamak, özellikle farklı konumlardaki etkinliklerle uğraşırken yanlış süre hesaplamalarına yol açabilir.
• Eski Date nesnesini kullanmak: Eski Date nesnesi, tuhaflıkları ve tutarsızlıkları ile bilinir. Daha güvenilir tarih ve saat yönetimi için Temporal API'yi tercih edin.
• Süreleri normalleştirmemek: Süreleri normalleştirmemek, karşılaştırmaları ve hesaplamaları daha karmaşık hale getirebilir.
• Yanlış ISO 8601 formatı: Geçersiz bir ISO 8601 süre string'i kullanmak hatalara neden olabilir.

Farklı Kültürlerde Gerçek Dünya Kullanım Alanları

Temporal API, saat dilimi farklılıklarının ve kültürel nüansların önemli olduğu küresel uygulamalarda özellikle faydalı olabilir. İşte bazı örnekler:

• Küresel Etkinlik Planlama: Yaz saati uygulaması geçişlerini dikkate alarak birden çok saat diliminde etkinlikleri doğru bir şekilde planlamak. Örneğin, PST ile sabah 9:00'da başlayan bir web seminerini planlamak ve karşılık gelen başlangıç zamanını CET, JST ve AEDT gibi çeşitli saat dilimlerinde görüntülemek.
• Uluslararası Seyahat Planlaması: Aktarmalar ve saat dilimi değişiklikleri dahil olmak üzere seyahat sürelerini hesaplamak. Bu, seyahat planları oluşturmak ve uçuş programlarını yönetmek için kullanışlıdır. Örneğin, New York'tan Tokyo'ya toplam seyahat süresini, Londra'da bir aktarma dahil olmak üzere ve saat dilimi farklılıklarına göre ayarlayarak hesaplamak.
• Küresel E-ticaret: Tahmini teslimat sürelerini kullanıcının yerel saat diliminde görüntülemek. Bu, başlangıç saat dilimini, nakliye süresini ve varış saat dilimini dikkate almayı gerektirir. Örneğin, Almanya'daki bir depodan Avustralya'daki bir müşteriye gönderilen ve tahmini teslimat süresi 7 gün olan bir ürünün, müşterinin yerel saatinde görüntülenmesi.
• Sınır Ötesi Finansal İşlemler: Farklı bölgeler arasında faiz tahakkukunu veya ödeme son tarihlerini doğru bir şekilde hesaplamak. Bu genellikle her ülkede farklı iş günlerini ve tatilleri dikkate almayı içerir. Örneğin, Singapur'daki bir kredinin birikmiş faizini, Singapur resmi tatillerini dikkate alarak hesaplamak.
• Çok Kültürlü Takvim Uygulamaları: İslami veya İbrani takvimi gibi çeşitli takvim sistemlerini desteklemek ve bu takvimlere göre etkinlik sürelerini ve hatırlatıcıları doğru bir şekilde hesaplamak.
• Küresel Proje Yönetimi: Farklı çalışma programlarını ve saat dilimlerini dikkate alarak dağıtılmış ekipler arasında proje görev sürelerini ve son tarihlerini izlemek.

Sonuç

Temporal.Duration, JavaScript'te zaman aralıklarıyla çalışmak için sağlam ve sezgisel bir yol sağlar. Özelliklerini ve en iyi uygulamalarını anlayarak, uygulamalarınızda güvenle doğru ve güvenilir süre hesaplamaları yapabilirsiniz. Temporal API'yi benimsemek, daha temiz, daha sürdürülebilir koda yol açar ve eski tarih ve saat yönetimiyle ilişkili hata riskini azaltır.

Temporal API'ye daha derinlemesine daldıkça, resmi belgeleri incelemeyi ve yeteneklerini tam olarak kavramak için farklı senaryolarla denemeler yapmayı unutmayın. Modern tasarımı ve kapsamlı özellikleriyle Temporal, JavaScript'te tarihleri, saatleri ve süreleri yönetme şeklimizi devrimleştirmeye hazırlanıyor.