JavaScript Temporal Instant: Kalkulasi Waktu Berpresisi Tinggi

JavaScript telah lama dikenal karena kemampuannya yang kurang ideal dalam menangani tanggal dan waktu. Objek Date lawas, meskipun banyak digunakan, memiliki kelemahan seperti mutabilitas, perilaku API yang tidak konsisten, dan dukungan yang buruk untuk zona waktu. Masuklah Temporal API, sebuah pendekatan modern untuk manipulasi tanggal dan waktu, yang dirancang untuk mengatasi kekurangan ini. Inti dari Temporal adalah objek Instant, yang merepresentasikan titik waktu tertentu dengan presisi nanodetik. Postingan blog ini menyediakan panduan komprehensif untuk menggunakan Temporal.Instant untuk kalkulasi waktu berpresisi tinggi dalam aplikasi JavaScript Anda, melayani audiens global dengan beragam kebutuhan.

Apa itu Temporal.Instant?

Temporal.Instant merepresentasikan sebuah titik waktu yang diukur dari epoch Unix (1 Januari 1970, pukul 00:00:00 Coordinated Universal Time (UTC)) dengan presisi nanodetik. Berbeda dengan objek Date lawas, Temporal.Instant bersifat immutable (tidak dapat diubah), yang berarti nilainya tidak dapat diubah setelah dibuat. Sifat immutable ini sangat penting untuk mencegah efek samping yang tidak terduga dan memastikan integritas data, terutama dalam aplikasi yang kompleks.

Membuat Objek Temporal.Instant

Ada beberapa cara untuk membuat objek Temporal.Instant:

1. Dari Angka (Milidetik Sejak Epoch)

Anda dapat membuat Instant dari jumlah milidetik yang telah berlalu sejak epoch Unix. Ini mirip dengan cara kerja objek Date lawas, tetapi Temporal.Instant menawarkan presisi yang lebih besar.

            
const instant = Temporal.Instant.fromEpochMilliseconds(1678886400000); // 15 Maret 2023, 00:00:00 UTC
console.log(instant.toString()); // Output: 2023-03-15T00:00:00Z

            

              
                Copy
              
            
          

2. Dari Angka (Nanodetik Sejak Epoch)

Untuk presisi yang lebih tinggi lagi, Anda dapat membuat Instant dari jumlah nanodetik yang telah berlalu sejak epoch Unix. Ini adalah cara paling presisi untuk merepresentasikan titik waktu dengan Temporal.Instant.

            
const instant = Temporal.Instant.fromEpochNanoseconds(1678886400000000000n); // 15 Maret 2023, 00:00:00 UTC
console.log(instant.toString()); // Output: 2023-03-15T00:00:00Z

            

              
                Copy
              
            
          

Perhatikan penggunaan akhiran n untuk menunjukkan literal BigInt. Nilai nanodetik seringkali melebihi nilai integer aman maksimum untuk angka JavaScript, jadi penggunaan BigInt diperlukan untuk menjaga presisi.

3. Dari String ISO 8601

Temporal.Instant juga dapat dibuat dari string ISO 8601 yang merepresentasikan tanggal dan waktu UTC.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
console.log(instant.toString()); // Output: 2023-03-15T00:00:00Z

const instantWithFractionalSeconds = Temporal.Instant.from('2023-03-15T00:00:00.123456789Z');
console.log(instantWithFractionalSeconds.toString()); // Output: 2023-03-15T00:00:00.123456789Z

            

              
                Copy
              
            
          

String ISO 8601 harus diakhiri dengan Z untuk menunjukkan UTC. String tersebut secara opsional dapat menyertakan pecahan detik dengan presisi hingga sembilan digit.

4. Dari Temporal.Now (Jam Sistem)

Anda bisa mendapatkan instan waktu saat ini menggunakan Temporal.Now.instant():

            
const now = Temporal.Now.instant();
console.log(now.toString()); // Output: Bervariasi tergantung pada waktu saat ini

            

              
                Copy
              
            
          

Bekerja dengan Objek Temporal.Instant

Setelah Anda memiliki objek Temporal.Instant, Anda dapat melakukan berbagai operasi padanya. Ingat bahwa objek Temporal.Instant bersifat immutable, jadi operasi ini mengembalikan objek Temporal.Instant baru alih-alih memodifikasi yang asli.

1. Menambah dan Mengurangi Waktu

Anda dapat menambah atau mengurangi waktu dari sebuah Instant menggunakan metode add() dan subtract(). Metode ini menerima objek Temporal.Duration, yang merepresentasikan rentang waktu.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const duration = Temporal.Duration.from({ hours: 2, minutes: 30 });

const futureInstant = instant.add(duration);
console.log(futureInstant.toString()); // Output: 2023-03-15T02:30:00Z

const pastInstant = instant.subtract(duration);
console.log(pastInstant.toString()); // Output: 2023-03-14T21:30:00Z

            

              
                Copy
              
            
          

Anda juga dapat menggunakan representasi string untuk durasi:

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const futureInstant = instant.add('PT2H30M'); // String durasi ISO 8601
console.log(futureInstant.toString()); // Output: 2023-03-15T02:30:00Z

            

              
                Copy
              
            
          

2. Membandingkan Instan

Anda dapat membandingkan dua objek Temporal.Instant menggunakan metode compare(). Metode ini mengembalikan:

• -1 jika instan pertama lebih awal dari yang kedua.
• 0 jika kedua instan sama.
• 1 jika instan pertama lebih lambat dari yang kedua.

            
const instant1 = Temporal.Instant.from('2023-03-15T00:00:00Z');
const instant2 = Temporal.Instant.from('2023-03-15T01:00:00Z');

console.log(Temporal.Instant.compare(instant1, instant2)); // Output: -1
console.log(Temporal.Instant.compare(instant2, instant1)); // Output: 1
console.log(Temporal.Instant.compare(instant1, instant1)); // Output: 0

            

              
                Copy
              
            
          

3. Mengonversi ke Tipe Temporal Lain

Temporal.Instant dapat dikonversi ke tipe Temporal lain, seperti Temporal.ZonedDateTime, Temporal.PlainDateTime, dan Temporal.PlainDate. Ini penting untuk bekerja dengan zona waktu dan representasi tanggal dan waktu yang dilokalkan.

a. Ke Temporal.ZonedDateTime

Temporal.ZonedDateTime merepresentasikan tanggal dan waktu dengan zona waktu tertentu. Untuk mengonversi Instant menjadi ZonedDateTime, Anda perlu menentukan zona waktunya.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const zonedDateTime = instant.toZonedDateTimeISO('America/Los_Angeles');
console.log(zonedDateTime.toString()); // Output: 2023-03-14T17:00:00-07:00[America/Los_Angeles]

            

              
                Copy
              
            
          

Metode toZonedDateTimeISO() membuat ZonedDateTime menggunakan kalender ISO 8601. Anda juga dapat menggunakan toZonedDateTime() untuk menentukan kalender yang berbeda.

b. Ke Temporal.PlainDateTime

Temporal.PlainDateTime merepresentasikan tanggal dan waktu tanpa zona waktu. Untuk mengonversi Instant menjadi PlainDateTime, Anda perlu mengubahnya menjadi ZonedDateTime terlebih dahulu dan kemudian mendapatkan PlainDateTime darinya.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const zonedDateTime = instant.toZonedDateTimeISO('America/Los_Angeles');
const plainDateTime = zonedDateTime.toPlainDateTime();
console.log(plainDateTime.toString()); // Output: 2023-03-14T17:00:00

            

              
                Copy
              
            
          

c. Ke Temporal.PlainDate

Temporal.PlainDate merepresentasikan tanggal tanpa waktu atau zona waktu. Mirip dengan PlainDateTime, Anda mengonversi ke ZonedDateTime terlebih dahulu.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const zonedDateTime = instant.toZonedDateTimeISO('America/Los_Angeles');
const plainDate = zonedDateTime.toPlainDate();
console.log(plainDate.toString()); // Output: 2023-03-14

            

              
                Copy
              
            
          

4. Mendapatkan Milidetik dan Nanodetik Sejak Epoch

Anda dapat mengambil jumlah milidetik atau nanodetik yang telah berlalu sejak epoch Unix menggunakan properti epochMilliseconds dan epochNanoseconds.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00.123456789Z');
console.log(instant.epochMilliseconds); // Output: 1678886400123
console.log(instant.epochNanoseconds); // Output: 1678886400123456789n

            

              
                Copy
              
            
          

Studi Kasus untuk Temporal.Instant

Temporal.Instant sangat berguna dalam skenario di mana kalkulasi waktu berpresisi tinggi diperlukan. Berikut adalah beberapa contoh:

1. Pencatatan Log dan Audit Peristiwa

Saat mencatat peristiwa atau mengaudit aktivitas sistem, sangat penting untuk menangkap waktu yang tepat saat suatu peristiwa terjadi. Temporal.Instant menyediakan presisi yang diperlukan untuk merekam stempel waktu secara akurat.

            
function logEvent(eventDescription) {
  const timestamp = Temporal.Now.instant().toString();
  console.log(`[${timestamp}] ${eventDescription}`);
}

logEvent('Pengguna masuk');
logEvent('File disimpan');

            

              
                Copy
              
            
          

2. Pengukuran Kinerja

Mengukur kinerja kode memerlukan pengaturan waktu yang akurat. Temporal.Instant dapat digunakan untuk mengukur waktu eksekusi blok kode dengan presisi nanodetik.

            
const start = Temporal.Now.instant();
// Kode untuk diukur
for (let i = 0; i < 1000000; i++) {
  // Beberapa operasi
}
const end = Temporal.Now.instant();

const duration = end.since(start);
console.log(`Waktu eksekusi: ${duration.total('milliseconds')} milidetik`);

            

              
                Copy
              
            
          

3. Sistem Terdistribusi dan Sinkronisasi Data

Dalam sistem terdistribusi, menjaga konsistensi data di beberapa node seringkali memerlukan sinkronisasi waktu yang presisi. Temporal.Instant dapat digunakan untuk merepresentasikan stempel waktu untuk pembaruan data dan menyelesaikan konflik berdasarkan waktu.

Misalnya, pertimbangkan skenario di mana data direplikasi di beberapa server di lokasi geografis yang berbeda (misalnya, jaringan pengiriman konten atau basis data terdistribusi). Jika pengguna memperbarui catatan, sistem perlu memastikan bahwa pembaruan terbaru disebarkan secara konsisten ke semua server. Menggunakan Temporal.Instant untuk memberi stempel waktu pada setiap pembaruan memastikan urutan yang akurat, bahkan dengan latensi jaringan dan potensi penyimpangan jam antar server.

4. Transaksi Keuangan

Transaksi keuangan seringkali memerlukan stempel waktu berpresisi tinggi untuk kepatuhan terhadap peraturan dan pencatatan yang akurat. Waktu yang tepat dari perdagangan, pembayaran, atau transfer harus dicatat dengan presisi untuk menghindari perselisihan dan memastikan akuntabilitas.

Sebagai contoh, sistem perdagangan frekuensi tinggi menuntut presisi mikodetik atau nanodetik untuk menangkap momen yang tepat saat pesanan dieksekusi. Bahkan perbedaan kecil dalam waktu dapat menyebabkan konsekuensi keuangan yang signifikan. Temporal.Instant menyediakan resolusi yang dibutuhkan untuk aplikasi kritis ini.

5. Aplikasi Ilmiah

Banyak aplikasi ilmiah, seperti astronomi, simulasi fisika, dan pencatatan data dari eksperimen, memerlukan pengukuran waktu yang sangat presisi. Pengukuran ini seringkali krusial untuk menganalisis data dan menarik kesimpulan yang akurat.

Bayangkan sebuah teleskop yang menangkap data dari bintang yang jauh. Waktu yang presisi dari setiap pengamatan sangat penting untuk menentukan posisi, pergerakan, dan properti lain dari bintang tersebut. Temporal.Instant memungkinkan para ilmuwan untuk mencatat stempel waktu ini dengan akurasi yang diperlukan.

Internasionalisasi dan Zona Waktu

Meskipun Temporal.Instant merepresentasikan titik waktu dalam UTC, penting untuk mempertimbangkan zona waktu saat bekerja dengan tanggal dan waktu untuk audiens global. Seperti yang ditunjukkan sebelumnya, Anda dapat mengonversi Instant menjadi Temporal.ZonedDateTime untuk merepresentasikan titik waktu yang sama di zona waktu tertentu.

Saat menampilkan tanggal dan waktu kepada pengguna, selalu gunakan zona waktu lokal mereka untuk menghindari kebingungan. Anda bisa mendapatkan zona waktu pengguna dari browser atau sistem operasi mereka. Misalnya, Anda mungkin menggunakan API Intl.DateTimeFormat untuk memformat tanggal dan waktu sesuai dengan lokal dan zona waktu pengguna.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const zonedDateTime = instant.toZonedDateTimeISO(Temporal.Now.timeZone());

const formatter = new Intl.DateTimeFormat(undefined, {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  hour: 'numeric',
  minute: 'numeric',
  timeZoneName: 'short',
});

console.log(formatter.format(zonedDateTime)); // Output: Bervariasi tergantung pada lokal dan zona waktu pengguna

            

              
                Copy
              
            
          

Contoh ini menggunakan zona waktu sistem pengguna. Anda dapat mengganti Temporal.Now.timeZone() dengan pengidentifikasi zona waktu tertentu (misalnya, 'America/Los_Angeles') jika diperlukan.

Catatan: Selalu perhatikan waktu musim panas (daylight saving time - DST) saat bekerja dengan zona waktu. Aturan zona waktu dapat berubah, jadi penting untuk menggunakan basis data zona waktu yang terbaru untuk memastikan perhitungan yang akurat. Temporal API secara otomatis menangani transisi DST saat mengonversi antar zona waktu.

Dukungan Browser dan Lingkungan

Pada akhir 2023, Temporal API masih relatif baru dan belum didukung sepenuhnya di semua browser dan lingkungan JavaScript. Anda mungkin perlu menggunakan polyfill untuk memberikan dukungan bagi browser yang lebih lama.

Paket @js-temporal/polyfill menyediakan polyfill untuk Temporal API. Anda dapat menginstalnya menggunakan npm atau yarn:

            
npm install @js-temporal/polyfill

            

              
                Copy
              
            
          

Kemudian, impor polyfill dalam kode JavaScript Anda:

            
import '@js-temporal/polyfill';

            

              
                Copy
              
            
          

Ini akan menambahkan Temporal API ke cakupan global, memungkinkan Anda untuk menggunakannya dalam kode Anda bahkan jika lingkungan tidak mendukungnya secara native.

Praktik Terbaik dan Pertimbangan

• Gunakan UTC untuk penyimpanan dan kalkulasi internal: Simpan semua stempel waktu dalam UTC untuk menghindari masalah terkait zona waktu. Konversikan ke zona waktu lokal hanya saat menampilkan tanggal dan waktu kepada pengguna.
• Tangani konversi zona waktu dengan hati-hati: Waspadai perubahan DST dan aturan zona waktu. Gunakan basis data zona waktu yang terbaru untuk memastikan konversi yang akurat.
• Gunakan BigInt untuk nilai nanodetik: Nilai nanodetik seringkali melebihi nilai integer aman maksimum untuk angka JavaScript. Gunakan BigInt untuk menjaga presisi.
• Pertimbangkan menggunakan polyfill: Jika Anda perlu mendukung browser atau lingkungan yang lebih lama, gunakan paket @js-temporal/polyfill.
• Uji kode Anda secara menyeluruh: Uji kode Anda dengan berbagai zona waktu dan lokal untuk memastikan kode berfungsi dengan benar untuk semua pengguna.
• Dokumentasikan asumsi Anda: Dokumentasikan dengan jelas setiap asumsi yang Anda buat tentang zona waktu, lokal, atau format tanggal dan waktu.

Kesimpulan

Temporal.Instant menyediakan cara yang kuat dan presisi untuk merepresentasikan titik waktu dalam JavaScript. Sifatnya yang immutable, presisi nanodetik, dan integrasinya dengan tipe Temporal lainnya menjadikannya alat yang ampuh untuk menangani kalkulasi waktu yang kompleks dalam berbagai aplikasi. Dengan memahami cara membuat, memanipulasi, dan membandingkan objek Instant, dan dengan mengikuti praktik terbaik untuk internasionalisasi dan penanganan zona waktu, Anda dapat membangun fungsionalitas tanggal dan waktu yang andal dan akurat untuk audiens global. Mengadopsi Temporal API, termasuk objek Instant, memungkinkan pengembang untuk melampaui batasan objek Date lawas dan membangun aplikasi yang lebih kuat dan mudah dipelihara yang secara akurat mencerminkan kompleksitas waktu di berbagai budaya dan wilayah.

Seiring dengan semakin luasnya adopsi Temporal API, ia siap menjadi standar untuk manipulasi tanggal dan waktu di JavaScript. Pengembang yang membiasakan diri dengan fitur-fitur dan praktik terbaiknya akan siap untuk membangun aplikasi sadar waktu generasi berikutnya.