Durasi Temporal JavaScript: Menguasai Perhitungan Interval Waktu

API Temporal JavaScript memperkenalkan cara modern dan kuat untuk menangani tanggal, waktu, dan interval waktu. Objek Temporal.Duration mewakili jangka waktu, memberikan pendekatan yang jelas dan intuitif untuk melakukan perhitungan dengan interval waktu. Artikel ini membahas detail Temporal.Duration, yang menunjukkan cara membuat, memanipulasi, dan memformat durasi untuk berbagai kasus penggunaan.

Apa itu Temporal.Duration?

Temporal.Duration mewakili rentang waktu, mengungkapkannya dalam tahun, bulan, hari, jam, menit, detik, dan sebagian kecil dari detik (milidetik, mikrodetik, nanodetik). Tidak seperti objek Date yang mewakili titik waktu tertentu, Temporal.Duration mewakili jumlah waktu. Ia mematuhi format durasi ISO 8601 (misalnya, P1Y2M10DT2H30M mewakili 1 tahun, 2 bulan, 10 hari, 2 jam, dan 30 menit). API Temporal dirancang agar lebih intuitif dan tidak rentan terhadap kesalahan daripada objek Date warisan.

Membuat Objek Temporal.Duration

Ada beberapa cara untuk membuat objek Temporal.Duration:

1. Dari Objek Biasa

Anda dapat membuat durasi dengan meneruskan objek dengan properti yang diinginkan:

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

Ini membuat durasi 1 tahun, 2 bulan, 10 hari, 2 jam, dan 30 menit. Perhatikan bahwa argumen sesuai dengan urutan berikut: tahun, bulan, minggu, hari, jam, menit, detik, milidetik, mikrodetik, nanodetik.

2. Dari String ISO 8601

Anda juga dapat membuat durasi dari string durasi ISO 8601 menggunakan Temporal.Duration.from():

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

Ini sangat berguna saat berurusan dengan durasi yang disimpan dalam format string atau diterima dari sumber eksternal.

3. Menggunakan metode add() dan subtract() dengan Temporal.Instant, Temporal.ZonedDateTime, dll.

Saat Anda menambah atau mengurangi Temporal.Duration dari tipe Temporal lainnya (seperti Temporal.Instant atau Temporal.ZonedDateTime), Temporal.Duration akan dikembalikan yang mewakili perbedaan antara dua titik waktu jika Anda kemudian menguranginya. Contohnya:

const now = Temporal.Now.zonedDateTimeISO();
const later = now.add({ jam: 5 });
const duration = later.since(now);
console.log(duration.toString()); // Output: PT5H

Mengakses Komponen Durasi

Anda dapat mengakses komponen individual dari objek Temporal.Duration menggunakan propertinya:

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

Melakukan Aritmatika dengan Durasi

Objek Temporal.Duration mendukung penambahan dan pengurangan menggunakan metode add() dan subtract(). Metode ini mengembalikan objek Temporal.Duration baru yang mewakili hasil operasi.

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

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

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

Anda juga dapat merangkai metode ini untuk perhitungan yang lebih kompleks:

const duration = Temporal.Duration.from("P1D").add({ jam: 12 }).subtract({ menit: 30 });
console.log(duration.toString()); // Output: P1DT11H30M

Metode negated() mengembalikan objek Temporal.Duration baru dengan semua komponen yang dinegasikan:

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

Metode abs() mengembalikan objek Temporal.Duration baru dengan semua komponen sebagai nilai positif (nilai absolut):

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

Metode with() memungkinkan Anda untuk membuat contoh Temporal.Duration baru dengan beberapa, atau semua, properti diubah menjadi nilai baru. Jika suatu nilai tidak ditentukan dalam objek argumen, maka nilai asli dari durasi akan digunakan. Contohnya:

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

Menormalkan Durasi

Durasi terkadang dapat dinyatakan dalam bentuk yang tidak dinormalisasi (misalnya, P1Y12M, yang dapat disederhanakan menjadi P2Y). Metode normalized() berupaya menyederhanakan durasi ke bentuknya yang paling ringkas. Namun, ini memerlukan tanggal referensi untuk menangani kompleksitas panjang bulan yang bervariasi. Untuk menormalkan dengan benar, Anda memerlukan instance Temporal.PlainDate, Temporal.ZonedDateTime, atau Temporal.Instant.

Misalnya, menormalkan durasi yang melibatkan bulan dan hari memerlukan tanggal referensi:

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

Dalam contoh ini, durasi P1M32D dinormalisasi relatif terhadap 1 Januari 2024, menghasilkan P2M1D karena bulan Januari memiliki 31 hari.

Jika Anda hanya berurusan dengan komponen waktu (jam, menit, detik, dll.), Anda dapat menormalkan tanpa tanggal referensi:

const duration = Temporal.Duration.from("PT25H61M");
const normalizedDuration = duration.normalized({ relativeTo: null }); //atau hilangkan argumen relativeTo
console.log(normalizedDuration.toString()); // Output: P1DT2H1M

Membandingkan Durasi

Anda dapat membandingkan durasi menggunakan metode compare(). Metode ini mengembalikan:

• -1 jika durasi pertama lebih pendek dari durasi kedua.
• 0 jika durasi sama.
• 1 jika durasi pertama lebih panjang dari durasi kedua.

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

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

Contoh Praktis

1. Menghitung Waktu Hingga Suatu Peristiwa

Misalkan Anda ingin menghitung sisa waktu hingga peristiwa tertentu. Menggunakan Temporal.Now.zonedDateTimeISO() untuk mendapatkan waktu saat ini, dan mengurangi tanggal peristiwa. Jika tanggal peristiwa telah berlalu, outputnya akan negatif.

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()); // Output: e.g., P262DT14H30M (tergantung pada tanggal dan waktu saat ini)

2. Melacak Durasi Tugas Proyek

Dalam manajemen proyek, Anda dapat menggunakan Temporal.Duration untuk melacak durasi tugas yang diperkirakan atau sebenarnya.

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

const totalEstimatedDuration = task1EstimatedDuration.add(task2EstimatedDuration);
console.log(`Total estimated duration: ${totalEstimatedDuration.toString()}`); // Output: Total estimated duration: P1DT

3. Menghitung Usia

Meskipun menghitung usia secara tepat memerlukan pertimbangan tahun kabisat dan zona waktu, Temporal.Duration dapat memberikan perkiraan yang wajar:

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

the ageDuration = currentDate.since(birthDate, { smallestUnit: 'years' });
console.log(`Perkiraan usia: ${ageDuration.years} tahun`); // Output: Perkiraan usia: 33 tahun

4. Menampilkan Durasi yang Dapat Dibaca Manusia

Seringkali, Anda perlu menampilkan durasi dalam format yang dapat dibaca manusia. Meskipun Temporal.Duration tidak memiliki fungsi pemformatan bawaan, Anda dapat membuat logika pemformatan khusus:

function formatDuration(duration) {
  const parts = [];
  if (duration.years) parts.push(`${duration.years} tahun${duration.years > 1 ? 's' : ''}`);
  if (duration.months) parts.push(`${duration.months} bulan${duration.months > 1 ? 's' : ''}`);
  if (duration.days) parts.push(`${duration.days} hari${duration.days > 1 ? 's' : ''}`);
  if (duration.hours) parts.push(`${duration.hours} jam${duration.hours > 1 ? 's' : ''}`);
  if (duration.minutes) parts.push(`${duration.minutes} menit${duration.minutes > 1 ? 's' : ''}`);
  if (duration.seconds) parts.push(`${duration.seconds} detik${duration.seconds > 1 ? 's' : ''}`);

  return parts.join(', ');
}

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const formattedDuration = formatDuration(duration);
console.log(formattedDuration); // Output: 1 tahun, 2 bulan, 10 hari, 2 jam, 30 menit

Penggunaan dan Pertimbangan Lanjutan

1. Penanganan Zona Waktu

Saat berurusan dengan interval waktu yang melintasi batas zona waktu atau transisi waktu musim panas, sangat penting untuk menggunakan Temporal.ZonedDateTime untuk memastikan perhitungan yang akurat. Menggunakan Temporal.PlainDate dan Temporal.PlainTime akan menghindari konversi zona waktu apa pun.

2. Satuan Terkecil dan Pembulatan

Metode `since()` dan `until()` sering menerima opsi untuk menentukan unit terkecil untuk durasi yang dihasilkan. Misalnya, menghitung waktu *hingga* suatu peristiwa dan membatasi hasil hingga beberapa hari.

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()); //contoh keluaran PT340D

3. Detik Kabisat

Temporal tidak memperhitungkan detik kabisat secara asli. Jika Anda memerlukan presisi ekstrem, Anda harus menangani detik kabisat secara terpisah.

4. Zona Waktu IANA

API Temporal bergantung pada database zona waktu IANA (Internet Assigned Numbers Authority). Pastikan lingkungan Anda memiliki versi terbaru dari database IANA untuk menangani konversi zona waktu secara akurat.

Praktik Terbaik

• Gunakan format ISO 8601 untuk string durasi: Ini memastikan konsistensi dan interoperabilitas.
• Pilih tipe Temporal yang sesuai: Gunakan Temporal.PlainDate, Temporal.PlainTime, Temporal.ZonedDateTime, atau Temporal.Instant berdasarkan apakah Anda memerlukan dukungan zona waktu atau tidak.
• Normalisasikan durasi jika perlu: Normalisasi menyederhanakan durasi dan membuatnya lebih mudah untuk dibandingkan.
• Tangani zona waktu dengan hati-hati: Konversi zona waktu bisa jadi rumit, jadi gunakan Temporal.ZonedDateTime dan waspadalah terhadap transisi waktu musim panas.
• Pertimbangkan unit terkecil: Saat menghitung durasi, tentukan unit terkecil untuk mendapatkan tingkat presisi yang diinginkan.
• Tulis pengujian unit: Uji kode Anda secara menyeluruh untuk memastikan bahwa perhitungan durasi akurat.

Potensi Masalah Umum

• Mengabaikan zona waktu: Gagal memperhitungkan zona waktu dapat menyebabkan perhitungan durasi yang salah, terutama saat berurusan dengan peristiwa di lokasi yang berbeda.
• Menggunakan objek Tanggal warisan: Objek Date warisan dikenal karena keanehan dan inkonsistensinya. Pilih API Temporal untuk penanganan tanggal dan waktu yang lebih andal.
• Tidak menormalkan durasi: Tidak menormalkan durasi dapat membuat perbandingan dan perhitungan lebih kompleks.
• Format ISO 8601 yang salah: Menggunakan string durasi ISO 8601 yang tidak valid dapat menyebabkan kesalahan.

Kasus Penggunaan Dunia Nyata di Berbagai Budaya

API Temporal dapat sangat bermanfaat dalam aplikasi global di mana perbedaan zona waktu dan nuansa budaya signifikan. Berikut beberapa contoh:

• Penjadwalan Acara Global: Menjadwalkan acara secara akurat di berbagai zona waktu, dengan mempertimbangkan transisi waktu musim panas. Misalnya, menjadwalkan webinar yang dimulai pukul 09.00 PST dan menampilkan waktu mulai yang sesuai di berbagai zona waktu seperti CET, JST, dan AEDT.
• Perencanaan Perjalanan Internasional: Menghitung durasi perjalanan, termasuk singgahan dan perubahan zona waktu. Ini berguna untuk menghasilkan rencana perjalanan dan mengelola jadwal penerbangan. Misalnya, menghitung total waktu perjalanan dari New York ke Tokyo, termasuk singgahan di London dan menyesuaikan perbedaan zona waktu.
• E-niaga Global: Menampilkan perkiraan waktu pengiriman di zona waktu lokal pengguna. Ini memerlukan mempertimbangkan zona waktu asal, durasi pengiriman, dan zona waktu tujuan. Misalnya, barang yang dikirim dari gudang di Jerman ke pelanggan di Australia, dengan perkiraan waktu pengiriman 7 hari, ditampilkan dalam waktu lokal pelanggan.
• Transaksi Keuangan Lintas Batas: Menghitung akrual bunga atau tenggat waktu pembayaran secara akurat di berbagai wilayah. Ini sering melibatkan mempertimbangkan hari kerja dan hari libur yang berbeda di setiap negara. Misalnya, menghitung bunga yang jatuh tempo atas pinjaman di Singapura, dengan memperhitungkan hari libur umum Singapura.
• Aplikasi Kalender Multikultural: Mendukung berbagai sistem kalender, seperti kalender Islam atau Ibrani, dan menghitung durasi acara dan pengingat secara akurat berdasarkan kalender ini.
• Manajemen Proyek Global: Melacak durasi dan tenggat waktu tugas proyek di seluruh tim yang terdistribusi, dengan mempertimbangkan jadwal kerja dan zona waktu yang berbeda.

Kesimpulan

Temporal.Duration memberikan cara yang kuat dan intuitif untuk bekerja dengan interval waktu di JavaScript. Dengan memahami fitur dan praktik terbaiknya, Anda dapat dengan percaya diri melakukan perhitungan durasi yang akurat dan andal dalam aplikasi Anda. Merangkul API Temporal mengarah pada kode yang lebih bersih, lebih mudah dirawat, dan mengurangi risiko kesalahan yang terkait dengan penanganan tanggal dan waktu warisan.

Saat Anda mempelajari lebih dalam API Temporal, ingatlah untuk berkonsultasi dengan dokumentasi resmi dan bereksperimen dengan berbagai skenario untuk memahami sepenuhnya kemampuannya. Dengan desainnya yang modern dan fitur yang komprehensif, Temporal siap untuk merevolusi cara kita menangani tanggal, waktu, dan durasi di JavaScript.