Menguasai Durasi Temporal JavaScript: Panduan Komprehensif untuk Perhitungan Interval Waktu

Temporal API JavaScript merupakan kemajuan signifikan dalam menangani tanggal dan waktu. Salah satu komponen intinya adalah objek Duration, yang dirancang khusus untuk mewakili interval waktu. Tidak seperti objek Date tradisional yang menderita karena mutabilitas dan kompleksitas zona waktu, Duration menawarkan cara yang lebih bersih, lebih presisi, dan sadar internasional untuk bekerja dengan rentang waktu. Panduan komprehensif ini akan menjelajahi objek Duration secara detail, mencakup segalanya dari penggunaan dasar hingga skenario lanjutan.

Apa itu Durasi Temporal?

Sebuah Temporal.Duration mewakili rentang waktu, independen dari sistem kalender atau zona waktu tertentu. Ini berfokus semata-mata pada jumlah waktu, dinyatakan dalam tahun, bulan, hari, jam, menit, detik, dan pecahan detik. Anggap saja sebagai "5 tahun, 3 bulan, dan 2 hari", bukan "dari 1 Januari 2023, hingga 3 Maret 2028".

Perbedaan ini sangat penting karena durasi pada dasarnya bersifat relatif. Menambahkan durasi ke tanggal tertentu akan selalu menghasilkan tanggal baru, tetapi hasil yang tepat bergantung pada sistem kalender dan tanggal awal. Sebagai contoh, menambahkan satu bulan ke 31 Januari menghasilkan tanggal yang berbeda tergantung pada apakah tahun tersebut adalah tahun kabisat.

Membuat Objek Durasi

Ada beberapa cara untuk membuat objek Temporal.Duration:

1. Dari Komponen

Cara paling langsung adalah menggunakan metode Temporal.Duration.from dengan objek yang berisi komponen yang diinginkan:

            const duration1 = Temporal.Duration.from({ years: 1, months: 6, days: 15 });
console.log(duration1.toString()); // Output: P1Y6M15D

const duration2 = Temporal.Duration.from({ hours: 8, minutes: 30, seconds: 12, milliseconds: 500 });
console.log(duration2.toString()); // Output: PT8H30M12.5S

const duration3 = Temporal.Duration.from({ years: 2, days: -5, seconds: 30 });
console.log(duration3.toString()); // Output: P2YT-5S30S

            

              
                Copy
              
            
          

Perhatikan bahwa Anda dapat menggunakan nilai negatif untuk mewakili durasi yang bergerak mundur dalam waktu.

2. Dari String ISO 8601

Metode Temporal.Duration.from juga menerima string durasi ISO 8601:

            const duration4 = Temporal.Duration.from('P3Y2M10DT5H30M');
console.log(duration4.toString()); // Output: P3Y2M10DT5H30M

const duration5 = Temporal.Duration.from('PT1H15M30S');
console.log(duration5.toString()); // Output: PT1H15M30S

const duration6 = Temporal.Duration.from('P-1Y');
console.log(duration6.toString()); // Output: P-1Y

            

              
                Copy
              
            
          

Format durasi ISO 8601 adalah P[tahun]Y[bulan]M[hari]D[T[jam]H[menit]M[detik]S]. 'P' menunjukkan periode (durasi), dan 'T' memisahkan komponen tanggal dan waktu.

3. Menggunakan Konstruktor

Anda juga dapat menggunakan konstruktor Temporal.Duration secara langsung:

            const duration7 = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7, 8);
console.log(duration7.toString()); // Output: P1Y2M3W4DT5H6M7S8ms

            

              
                Copy
              
            
          

Argumen konstruktor berada dalam urutan: years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds.

Properti Durasi

Setelah Anda memiliki objek Duration, Anda dapat mengakses komponennya menggunakan propertinya:

            const duration = Temporal.Duration.from('P1Y2M3DT4H5M6S');

console.log(duration.years);       // Output: 1
console.log(duration.months);      // Output: 2
console.log(duration.days);        // Output: 3
console.log(duration.hours);       // Output: 4
console.log(duration.minutes);     // Output: 5
console.log(duration.seconds);     // Output: 6
console.log(duration.milliseconds);  // Output: 0
console.log(duration.microseconds);  // Output: 0
console.log(duration.nanoseconds);   // Output: 0

            

              
                Copy
              
            
          

Aritmetika Durasi

Objek Duration menyediakan metode untuk melakukan operasi aritmetika:

1. Menambahkan Durasi

Gunakan metode add untuk menambahkan dua durasi bersama:

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

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

            

              
                Copy
              
            
          

2. Mengurangkan Durasi

Gunakan metode subtract untuk mengurangi satu durasi dari durasi lainnya:

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

const difference = duration1.subtract(duration2);
console.log(difference.toString()); // Output: PPT11M-4D

            

              
                Copy
              
            
          

3. Menegasikan Durasi

Gunakan metode negated untuk membalikkan tanda semua komponen dalam durasi:

            const duration = Temporal.Duration.from('P1Y2M-3D');
const negatedDuration = duration.negated();
console.log(negatedDuration.toString()); // Output: P-1YT-2M3D

            

              
                Copy
              
            
          

4. Nilai Absolut dari Durasi

Gunakan metode abs untuk mendapatkan durasi dengan semua komponen positif:

            const duration = Temporal.Duration.from('P-1YT2M-3D');
const absoluteDuration = duration.abs();
console.log(absoluteDuration.toString()); // Output: P1YT2M3D

            

              
                Copy
              
            
          

5. Mengalikan Durasi

Gunakan metode multiply untuk mengalikan durasi dengan sebuah angka:

            const duration = Temporal.Duration.from('PT1H30M');
const multipliedDuration = duration.multiply(2.5);
console.log(multipliedDuration.toString()); // Output: PT3H45M

            

              
                Copy
              
            
          

6. Membulatkan Durasi

Gunakan metode round untuk membulatkan durasi ke unit tertentu. Ini memerlukan penyediaan opsi relativeTo, yang dapat berupa Temporal.PlainDateTime atau Temporal.ZonedDateTime, karena beberapa unit (seperti bulan dan tahun) memiliki panjang yang bervariasi.

            const duration = Temporal.Duration.from('P1DT12H30M');
const relativeTo = Temporal.PlainDateTime.from('2024-01-01T00:00:00');

const roundedDuration = duration.round({ smallestUnit: 'days', relativeTo });
console.log(roundedDuration.toString()); // Output: P2D

            

              
                Copy
              
            
          

Dalam contoh ini, 1 hari dan 12 jam dibulatkan menjadi 2 hari.

Membandingkan Durasi

Anda dapat membandingkan dua durasi menggunakan metode compare. Namun, perlu diingat bahwa durasi dengan unit campuran (misalnya, tahun dan hari) tidak dapat dibandingkan secara andal tanpa konteks relatif (tanggal dan kalender tertentu). Fungsi compare mengembalikan:

• -1 jika durasi1 lebih kecil dari durasi2
• 0 jika durasi1 sama dengan durasi2
• 1 jika durasi1 lebih besar dari durasi2

            const duration1 = Temporal.Duration.from('PT1H');
const duration2 = Temporal.Duration.from('PT30M');

console.log(Temporal.Duration.compare(duration1, duration2)); // Output: 1
console.log(Temporal.Duration.compare(duration2, duration1)); // Output: -1
console.log(Temporal.Duration.compare(duration1, Temporal.Duration.from('PT1H'))); // Output: 0

const duration3 = Temporal.Duration.from('P1M');
const duration4 = Temporal.Duration.from('P30D');

// Membandingkan durasi3 dan durasi4 secara langsung akan menimbulkan error di banyak engine
// kecuali 'relativeTo' ditentukan, karena panjang bulan tidak konstan.

            

              
                Copy
              
            
          

Contoh Praktis dan Kasus Penggunaan

Objek Temporal.Duration sangat serbaguna dan dapat digunakan dalam berbagai aplikasi:

1. Menghitung Durasi Proyek

Bayangkan Anda mengelola proyek dengan tanggal mulai dan tanggal selesai. Anda dapat menggunakan Temporal.PlainDate dan Temporal.Duration untuk menghitung durasi proyek:

            const startDate = Temporal.PlainDate.from('2024-01-15');
const endDate = Temporal.PlainDate.from('2024-03-20');

const duration = endDate.since(startDate);
console.log(duration.toString()); // Output: P1M5D

            

              
                Copy
              
            
          

2. Menjadwalkan Acara Berulang

Anda dapat menggunakan Temporal.Duration untuk menentukan frekuensi acara berulang, seperti rapat mingguan atau laporan bulanan:

            const eventFrequency = Temporal.Duration.from({ weeks: 1 });
let nextEventDate = Temporal.PlainDate.from('2024-01-22');

for (let i = 0; i < 5; i++) {
  console.log(`Event ${i + 1}: ${nextEventDate.toString()}`);
  nextEventDate = nextEventDate.add(eventFrequency);
}

// Output:
// Event 1: 2024-01-22
// Event 2: 2024-01-29
// Event 3: 2024-02-05
// Event 4: 2024-02-12
// Event 5: 2024-02-19

            

              
                Copy
              
            
          

3. Menghitung Usia

Meskipun menghitung usia secara tepat memerlukan penanganan tahun kabisat dan sistem kalender yang berbeda, Temporal.Duration dapat memberikan perkiraan yang baik:

            const birthDate = Temporal.PlainDate.from('1990-05-10');
const today = Temporal.PlainDate.from('2024-02-15');

const ageDuration = today.since(birthDate);

console.log(`Perkiraan usia: ${ageDuration.years} tahun, ${ageDuration.months} bulan, ${ageDuration.days} hari`);

            

              
                Copy
              
            
          

4. Perhitungan Sadar Zona Waktu: Durasi Penerbangan

Untuk aplikasi global, penanganan zona waktu sangat penting. Pertimbangkan untuk menghitung durasi penerbangan antara zona waktu yang berbeda:

            const departureZonedDateTime = Temporal.ZonedDateTime.from('2024-03-15T10:00:00[America/Los_Angeles]');
const arrivalZonedDateTime = Temporal.ZonedDateTime.from('2024-03-16T14:30:00[Europe/London]');

const flightDuration = arrivalZonedDateTime.since(departureZonedDateTime);

console.log(`Durasi Penerbangan: ${flightDuration.hours} jam, ${flightDuration.minutes} menit`);
console.log(flightDuration.toString());

            

              
                Copy
              
            
          

Contoh ini menunjukkan bagaimana Temporal.ZonedDateTime, ketika digabungkan dengan .since(), secara otomatis menyesuaikan perbedaan zona waktu, memberikan durasi penerbangan yang akurat.

5. Melacak Perjanjian Tingkat Layanan (SLA)

Banyak layanan online menjanjikan jaminan waktu aktif. Anda dapat menggunakan `Temporal.Duration` untuk mendefinisikan dan melacak perjanjian ini.

            const slaGuarantee = Temporal.Duration.from('PT99H59M59S'); // Hampir 100 jam
const downtime = Temporal.Duration.from('PT1H');

if (downtime.compare(slaGuarantee) > 0) {
  console.log("SLA dilanggar!");
} else {
  console.log("SLA terpenuhi.");
}

            

              
                Copy
              
            
          

Pertimbangan Lanjutan

1. Ambiguitas Bulan dan Tahun

Seperti yang disebutkan sebelumnya, panjang bulan dan tahun dapat bervariasi. Saat melakukan perhitungan yang melibatkan unit-unit ini, seringkali perlu untuk menyediakan konteks relatif menggunakan Temporal.PlainDateTime atau Temporal.ZonedDateTime. Ini sangat penting saat membulatkan atau membandingkan durasi.

2. Sistem Kalender

Temporal API mendukung sistem kalender yang berbeda. Secara default, ia menggunakan kalender ISO 8601, yang paling banyak digunakan. Namun, Anda dapat menentukan sistem kalender lain saat membuat objek Temporal.PlainDate atau Temporal.ZonedDateTime. Durasi tetap agnostik terhadap kalender; mereka mewakili kuantitas waktu.

3. Pembaruan Basis Data Zona Waktu

Aturan zona waktu dapat berubah seiring waktu karena alasan politik atau geografis. Sangat penting untuk menjaga basis data zona waktu Anda tetap mutakhir untuk memastikan perhitungan yang akurat, terutama saat berhadapan dengan Temporal.ZonedDateTime. Runtime JavaScript modern biasanya menangani ini secara otomatis, tetapi di beberapa lingkungan, Anda mungkin perlu memperbarui basis data secara manual.

Praktik Terbaik

• Gunakan string durasi ISO 8601 untuk serialisasi dan pertukaran data. Ini memastikan interoperabilitas dan menghindari ambiguitas.
• Pilih Temporal.Duration untuk mewakili interval waktu, daripada menghitung perbedaan antara dua objek Date secara langsung. Ini menghasilkan kode yang lebih bersih dan lebih mudah dipelihara.
• Waspadai ambiguitas bulan dan tahun, dan selalu berikan konteks relatif bila diperlukan.
• Gunakan Temporal.ZonedDateTime untuk perhitungan yang sadar zona waktu.
• Jaga agar basis data zona waktu Anda tetap mutakhir.
• Saat membandingkan durasi dengan unit campuran, selalu gunakan round dengan konteks relatif untuk memastikan perbandingan yang akurat.

Kesimpulan

Objek Temporal.Duration menyediakan cara yang kuat dan intuitif untuk bekerja dengan interval waktu di JavaScript. Dengan memahami properti, metode, dan praktik terbaiknya, Anda dapat menulis kode yang lebih tangguh, akurat, dan sadar internasional. Temporal API, dan khususnya objek Duration, merupakan langkah maju yang signifikan dalam penanganan tanggal dan waktu JavaScript, membuatnya lebih mudah untuk membangun aplikasi yang presisi dan relevan secara global. Rangkullah Temporal API dan buka potensinya untuk menyederhanakan perhitungan terkait waktu Anda.

Seiring Temporal API terus berkembang, tetaplah terinformasi tentang fitur dan pembaruan baru. Proposal resmi ECMAScript dan dokumentasi terkait adalah sumber daya yang sangat baik untuk tetap mengikuti perkembangan terkini.