Durasi Temporal JavaScript: Menguasai Aritmetika Interval Waktu

API Temporal JavaScript merevolusi cara kita menangani tanggal dan waktu. Di jantungnya terdapat objek Temporal.Duration, sebuah alat canggih untuk merepresentasikan dan memanipulasi interval waktu. Panduan komprehensif ini akan mendalami seluk-beluk Temporal.Duration, membekali Anda dengan pengetahuan untuk melakukan aritmetika temporal yang kompleks dengan mudah dan presisi.

Apa itu Temporal.Duration?

Temporal.Duration merepresentasikan rentang waktu, yang dinyatakan dalam tahun, bulan, hari, jam, menit, detik, dan nanodetik. Tidak seperti Date, yang merepresentasikan titik waktu tertentu, Duration menggambarkan jumlah waktu relatif. Ini membuatnya ideal untuk perhitungan yang melibatkan perbedaan waktu, offset, dan acara berulang.

Anggap saja ini sebagai resep untuk waktu. Ini memberi tahu Anda berapa banyak dari setiap unit waktu untuk ditambahkan atau dikurangi dari titik awal tertentu. Misalnya, durasi "1 tahun, 2 bulan, dan 3 hari" dapat digunakan untuk menghitung tanggal 1 tahun, 2 bulan, dan 3 hari setelah tanggal tertentu.

Membuat Objek Temporal.Duration

Ada beberapa cara untuk membuat objek Temporal.Duration:

1. Dari Literal Objek

Pendekatan yang paling mudah adalah menggunakan literal objek dengan properti untuk setiap unit waktu:

            const duration = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7); // 1 tahun, 2 bulan, 3 hari, 4 jam, 5 menit, 6 detik, 7 nanodetik
console.log(duration.toString()); // 'P1Y2M3DT4H5M6.000000007S'
            

              
                Copy
              
            
          

Anda dapat menghilangkan properti yang bernilai nol. Sebagai contoh:

            const duration = new Temporal.Duration(0, 0, 7); // 7 hari
console.log(duration.toString()); // 'P7D'
            

              
                Copy
              
            
          

2. Dari String ISO 8601

Temporal.Duration juga dapat dibuat dari string durasi ISO 8601:

            const duration = Temporal.Duration.from('P1Y2M3DT4H5M6S'); // 1 tahun, 2 bulan, 3 hari, 4 jam, 5 menit, 6 detik
console.log(duration.toString()); // 'P1Y2M3DT4H5M6S'

const duration2 = Temporal.Duration.from('PT30M'); // 30 menit
console.log(duration2.toString()); // 'PT30M'
            

              
                Copy
              
            
          

Metode ini sangat berguna saat berurusan dengan data dari sumber eksternal yang menggunakan format ISO 8601. Format string mengikuti pola P[tahun]Y[bulan]M[hari]D[T[jam]H[menit]M[detik]S].

3. Dari Tipe Temporal Lainnya

Anda dapat menghitung durasi antara dua objek Temporal.Instant, Temporal.ZonedDateTime, Temporal.PlainDate, atau Temporal.PlainTime menggunakan metode until(). Ini sangat berguna untuk menentukan waktu yang telah berlalu antara dua peristiwa.

            const start = Temporal.PlainDate.from('2023-01-01');
const end = Temporal.PlainDate.from('2023-03-15');
const duration = start.until(end);
console.log(duration.toString()); // 'P2M14D'
            

              
                Copy
              
            
          

Mengakses Properti Durasi

Setelah Anda memiliki objek Temporal.Duration, Anda dapat mengakses propertinya untuk mengambil komponen waktu individual:

            const duration = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7);

console.log(duration.years); // 1
console.log(duration.months); // 2
console.log(duration.days); // 3
console.log(duration.hours); // 4
console.log(duration.minutes); // 5
console.log(duration.seconds); // 6
console.log(duration.nanoseconds); // 7
            

              
                Copy
              
            
          

Properti-properti ini bersifat hanya-baca (read-only), memastikan bahwa objek Duration tetap tidak dapat diubah (immutable).

Aritmetika Temporal.Duration

Salah satu kekuatan utama dari Temporal.Duration adalah kemampuannya untuk melakukan operasi aritmetika. Anda dapat menambah, mengurangi, mengalikan, dan membagi durasi, membuat perhitungan waktu yang kompleks menjadi jauh lebih mudah.

1. Menambahkan Durasi

Gunakan metode add() untuk menambahkan dua durasi bersama-sama:

            const duration1 = new Temporal.Duration(1, 2, 3);
const duration2 = new Temporal.Duration(0, 0, 7);
const sum = duration1.add(duration2);
console.log(sum.toString()); // 'P1Y2M10D'
            

              
                Copy
              
            
          

2. Mengurangi Durasi

Gunakan metode subtract() untuk mengurangi satu durasi dari durasi lainnya:

            const duration1 = new Temporal.Duration(1, 2, 3);
const duration2 = new Temporal.Duration(0, 0, 7);
const difference = duration1.subtract(duration2);
console.log(difference.toString()); // 'P1Y2M-4D'
            

              
                Copy
              
            
          

Perhatikan bahwa mengurangi durasi yang lebih besar dari yang lebih kecil dapat menghasilkan nilai negatif untuk beberapa properti.

3. Mengalikan Durasi

Gunakan metode multiply() untuk mengalikan durasi dengan nilai skalar:

            const duration = new Temporal.Duration(1, 0, 0);
const doubled = duration.multiply(2);
console.log(doubled.toString()); // 'P2Y'
            

              
                Copy
              
            
          

Ini berguna untuk menskalakan durasi untuk merepresentasikan, misalnya, dua kali panjang suatu peristiwa tertentu.

4. Membagi Durasi

Gunakan metode negated() atau abs() untuk mengubah durasi:

            const duration = new Temporal.Duration(1, 0, 0);
const negated = duration.negated();
console.log(negated.toString()); // 'P-1Y'

const durationNegative = new Temporal.Duration(-1, 0, 0);
const absoluteValue = durationNegative.abs();
console.log(absoluteValue.toString()); // 'P1Y'

            

              
                Copy
              
            
          

Menormalisasi Durasi

Durasi terkadang bisa dalam keadaan tidak dinormalisasi, artinya durasi tersebut mengandung komponen yang dapat dinyatakan dalam unit yang lebih besar. Misalnya, durasi "1 tahun dan 12 bulan" dapat dinormalisasi menjadi "2 tahun".

Untuk menormalisasi durasi, Anda dapat menggunakan metode toPlainDays(), toPlainHours(), toPlainMinutes(), toPlainSeconds(), atau toPlainNanoseconds() bersama dengan tipe Temporal lain seperti Temporal.PlainDate. Normalisasi memerlukan konteks untuk memperhitungkan bulan dengan panjang variabel dan tahun kabisat dengan benar.

            const plainDate = Temporal.PlainDate.from('2024-01-01'); // Contoh tanggal mulai
const duration = new Temporal.Duration(0, 13, 0); // 13 bulan

// Menormalisasi ke konteks tanggal
const normalizedDate = plainDate.add(duration);

// Menghitung durasi dari tanggal awal ke tanggal yang dinormalisasi
const normalizedDuration = plainDate.until(normalizedDate);
console.log(normalizedDuration.toString()); // Output: 'P1Y1M'
            

              
                Copy
              
            
          

Dalam contoh ini, menambahkan durasi 13 bulan ke 1 Januari 2024, menghasilkan 1 Februari 2025. Metode until() kemudian menghitung durasi antara tanggal awal dan tanggal hasil, memberi kita durasi yang dinormalisasi yaitu 1 tahun dan 1 bulan.

Bekerja dengan Tipe Temporal yang Berbeda

Temporal.Duration dirancang untuk bekerja dengan mulus dengan tipe Temporal lainnya, seperti Temporal.Instant, Temporal.ZonedDateTime, Temporal.PlainDate, dan Temporal.PlainTime. Ini memungkinkan Anda untuk melakukan perhitungan temporal yang kompleks yang melibatkan titik waktu dan tanggal tertentu.

1. Menambahkan Durasi ke Temporal.PlainDate

Anda dapat menambahkan Duration ke Temporal.PlainDate untuk menghitung tanggal di masa depan:

            const startDate = Temporal.PlainDate.from('2023-01-01');
const duration = new Temporal.Duration(1, 0, 0); // 1 tahun
const futureDate = startDate.add(duration);
console.log(futureDate.toString()); // '2024-01-01'
            

              
                Copy
              
            
          

2. Mengurangi Durasi dari Temporal.ZonedDateTime

Demikian pula, Anda dapat mengurangi Duration dari Temporal.ZonedDateTime untuk menghitung tanggal dan waktu di masa lalu:

            const startDateTime = Temporal.ZonedDateTime.from('2023-01-01T12:00:00+00:00[UTC]');
const duration = new Temporal.Duration(0, 0, 0, 6); // 6 jam
const pastDateTime = startDateTime.subtract(duration);
console.log(pastDateTime.toString()); // '2023-01-01T06:00:00+00:00[UTC]'
            

              
                Copy
              
            
          

Contoh Praktis dan Kasus Penggunaan

Temporal.Duration adalah alat serbaguna dengan banyak aplikasi praktis. Berikut adalah beberapa contoh:

1. Menghitung Usia

Anda dapat menggunakan Temporal.Duration untuk menghitung usia seseorang berdasarkan tanggal lahir mereka:

            const birthDate = Temporal.PlainDate.from('1990-05-15');
const today = Temporal.Now.plainDateISO();
const ageDuration = birthDate.until(today);

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

              
                Copy
              
            
          

2. Menjadwalkan Acara Berulang

Temporal.Duration sangat ideal untuk menjadwalkan acara berulang, seperti rapat mingguan atau laporan bulanan. Anda dapat menggunakannya untuk menghitung kejadian berikutnya dari suatu acara berdasarkan interval perulangannya.

3. Menghitung Perbedaan Waktu untuk Perencanaan Perjalanan

Saat merencanakan perjalanan internasional, Anda dapat menggunakan Temporal.Duration untuk menghitung perbedaan waktu antara dua lokasi:

            const departureTime = Temporal.ZonedDateTime.from('2023-03-01T10:00:00+01:00[Europe/Paris]');
const arrivalTime = Temporal.ZonedDateTime.from('2023-03-01T14:00:00-08:00[America/Los_Angeles]');
const flightDuration = departureTime.until(arrivalTime);

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

              
                Copy
              
            
          

4. Mengimplementasikan Penghitung Waktu Mundur

Buat penghitung waktu mundur untuk acara khusus, peluncuran produk, atau tenggat waktu, dengan menampilkan sisa waktu secara dinamis.

5. Mengukur Metrik Kinerja

Catat durasi bagian eksekusi kode penting untuk mengidentifikasi hambatan kinerja dan mengoptimalkan kode.

Pertimbangan Internasionalisasi

Saat bekerja dengan tanggal dan waktu dalam konteks global, sangat penting untuk mempertimbangkan internasionalisasi. API Temporal menyediakan beberapa fitur untuk membantu Anda menangani berbagai zona waktu, kalender, dan lokal.

1. Zona Waktu

Gunakan Temporal.ZonedDateTime untuk bekerja dengan tanggal dan waktu di zona waktu tertentu. Ini memastikan bahwa perhitungan Anda akurat, terlepas dari lokasi pengguna.

2. Kalender

API Temporal mendukung berbagai kalender, seperti kalender Gregorian, kalender Islam, dan kalender Jepang. Anda dapat menentukan kalender saat membuat objek Temporal.PlainDate atau Temporal.ZonedDateTime.

3. Lokal

Gunakan metode toLocaleString() untuk memformat tanggal dan waktu sesuai dengan lokal pengguna. Ini memastikan bahwa tanggal dan waktu ditampilkan dengan cara yang sesuai secara budaya.

            const date = Temporal.PlainDate.from('2023-03-15');

console.log(date.toLocaleString('en-US')); // '3/15/2023'
console.log(date.toLocaleString('fr-FR')); // '15/03/2023'
console.log(date.toLocaleString('ja-JP')); // '2023/03/15'
            

              
                Copy
              
            
          

Praktik Terbaik untuk Bekerja dengan Temporal.Duration

Untuk memastikan bahwa kode Anda kuat dan dapat dipelihara, ikuti praktik terbaik ini saat bekerja dengan Temporal.Duration:

• Gunakan API Temporal secara konsisten: Hindari mencampur API Temporal dengan objek Date lawas, karena ini dapat menyebabkan inkonsistensi dan kesalahan.
• Tangani zona waktu dengan hati-hati: Selalu tentukan zona waktu saat bekerja dengan tanggal dan waktu yang relevan dengan lokasi tertentu.
• Validasi input pengguna: Validasi input pengguna untuk memastikan bahwa formatnya benar dan dalam rentang yang diharapkan.
• Uji kode Anda secara menyeluruh: Uji kode Anda dengan berbagai zona waktu, kalender, dan lokal untuk memastikan bahwa kode tersebut berfungsi dengan benar di semua skenario.
• Dokumentasikan kode Anda: Dokumentasikan kode Anda dengan jelas dan ringkas, jelaskan tujuan setiap fungsi dan asumsi yang dibuatnya.

Kesalahan Umum dan Cara Menghindarinya

Meskipun API Temporal menyederhanakan penanganan tanggal dan waktu, beberapa kesalahan dapat menyebabkan hasil yang tidak terduga. Mengetahui masalah umum ini dan cara menghindarinya sangat penting untuk menulis kode yang andal.

1. Format String Durasi yang Salah

Pastikan bahwa string durasi sesuai dengan format ISO 8601 secara ketat. Bahkan penyimpangan kecil dapat menyebabkan kesalahan parsing atau perhitungan yang salah.

            // Salah: 'T' hilang untuk komponen waktu
// Temporal.Duration.from('P1D2H3M'); // Ini mungkin akan menimbulkan kesalahan atau menghasilkan hasil yang tidak terduga

// Benar: Format ISO 8601 yang tepat
const duration = Temporal.Duration.from('P1DT2H3M');
console.log(duration.toString()); // Output: 'P1DT2H3M'
            

              
                Copy
              
            
          

2. Mengabaikan Tahun Kabisat dan Waktu Musim Panas (Daylight Saving Time)

Tahun kabisat dan waktu musim panas (Daylight Saving Time - DST) dapat secara signifikan memengaruhi perhitungan durasi, terutama saat berhadapan dengan interval waktu yang panjang. Selalu gunakan tipe dan metode Temporal yang sesuai untuk memperhitungkan anomali ini.

            // Contoh dengan Daylight Saving Time
const plainDateTime = Temporal.PlainDate.from('2023-03-12'); // Hari perubahan DST di AS
const duration1Day = Temporal.Duration.from('P1D');
const nextDay = plainDateTime.add(duration1Day);

console.log(nextDay.toString()); // Tanggal akan berubah dengan benar, memperhitungkan perubahan waktu karena DST
            

              
                Copy
              
            
          

3. Mencampur Tipe Temporal Secara Tidak Tepat

Pastikan Anda menggunakan tipe Temporal yang benar untuk perhitungan Anda. Misalnya, hindari menggunakan Temporal.PlainDate untuk operasi yang memerlukan kesadaran zona waktu.

4. Asumsi Normalisasi yang Salah

Selalu normalisasi durasi dalam konteks tertentu (misalnya, relatif terhadap Temporal.PlainDate) untuk menangani unit ambigu seperti bulan atau tahun secara akurat.

            // Salah: Mengasumsikan sebulan selalu 30 hari
const duration = new Temporal.Duration(0, 1, 0); // 1 bulan
// const daysInMonth = duration.months * 30; // Ini tidak akurat

// Benar: Menggunakan Temporal.PlainDate untuk menentukan hari dalam bulan tertentu
const startDate = Temporal.PlainDate.from('2023-02-01');
const endDate = startDate.add({ months: 1 });
const daysInMonth = startDate.until(endDate, { unit: 'days' }).days;
console.log(daysInMonth); // Output: 28 (untuk Februari 2023)
            

              
                Copy
              
            
          

Kesimpulan

Temporal.Duration adalah alat yang ampuh untuk bekerja dengan interval waktu di JavaScript. Dengan memahami properti, metode, dan praktik terbaiknya, Anda dapat melakukan aritmetika temporal yang kompleks dengan mudah dan presisi. Seiring API Temporal mendapatkan adopsi yang lebih luas, menguasai Temporal.Duration akan menjadi keterampilan penting bagi setiap pengembang JavaScript. Baik Anda menghitung usia, menjadwalkan acara, atau merencanakan perjalanan internasional, Temporal.Duration menyediakan solusi yang kuat dan andal untuk semua kebutuhan terkait waktu Anda. Rangkullah API Temporal dan buka tingkat presisi dan kejelasan baru dalam kode JavaScript Anda.

Panduan ini telah membahas aspek-aspek inti dari Temporal.Duration. Saat Anda mendalami API Temporal lebih jauh, jelajahi fitur-fitur canggihnya, seperti kalender kustom dan penanganan zona waktu, untuk lebih meningkatkan keterampilan pemrograman temporal Anda. Ingatlah untuk berkonsultasi dengan dokumentasi resmi ECMAScript Temporal untuk informasi dan spesifikasi terbaru.

Selamat membuat kode!