API Tanggal Temporal di Javascript Sangat Bagus, Inilah Alasannya:

💡

Sebelum kita mulai, izinkan saya memberikan pengumuman singkat: unduh Apidog secara gratis hari ini untuk menyederhanakan proses pengujian API Anda, terutama untuk menjelajahi fitur-fitur canggih Claude 3.7 Sonnet—sempurna untuk pengembang yang ingin menguji model AI mutakhir seperti ini!

button

Bekerja dengan tanggal dan waktu telah lama menjadi masalah bagi pengembang JavaScript. Objek Date bawaan, dengan keanehan dan keterbatasannya, telah mendorong banyak pengembang untuk menggunakan pustaka pihak ketiga seperti Moment.js atau date-fns. Namun, komite TC39 (yang bertanggung jawab untuk mengembangkan JavaScript) telah mengerjakan solusi: Temporal API. Pendekatan modern dan komprehensif untuk penanganan tanggal dan waktu ini menjanjikan untuk menyelesaikan masalah lama dengan operasi temporal JavaScript.

Masalah dengan Objek Date JavaScript

Sebelum menyelami Temporal API, penting untuk memahami keterbatasan objek Date saat ini:

Keadaan yang dapat berubah: Objek Date dapat dimodifikasi di tempat, yang menyebabkan efek samping yang tidak terduga
Fungsi terbatas: Operasi sederhana seperti menambahkan hari atau membandingkan tanggal memerlukan kode yang kompleks
Ketidakkonsistenan penguraian string: Penguraian tanggal dari string sangat tidak dapat diandalkan di seluruh browser
Tidak ada dukungan zona waktu: Penanganan zona waktu yang buruk di luar UTC dan waktu lokal
Hanya kalender Gregorian: Tidak ada dukungan untuk sistem kalender lain
API yang membingungkan: Metode seperti getMonth() mengembalikan nilai yang diindeks nol (0-11, bukan 1-12)

Masalah-masalah ini telah membuat bekerja dengan tanggal di JavaScript rentan terhadap kesalahan dan membuat frustrasi, yang mengarah pada adopsi luas pustaka pihak ketiga.

Memperkenalkan Temporal API

Temporal API adalah usulan tambahan untuk JavaScript yang menyediakan solusi modern dan komprehensif untuk bekerja dengan tanggal dan waktu. Ini dirancang sebagai objek global (Temporal) yang bertindak sebagai namespace tingkat atas (mirip dengan objek Math), yang berisi berbagai kelas untuk operasi tanggal dan waktu yang berbeda.

Prinsip-prinsip utama di balik Temporal API meliputi:

Imutabilitas: Semua objek Temporal tidak dapat diubah, menghilangkan efek samping
Kejelasan: Pemisahan yang jelas antara berbagai jenis konsep tanggal/waktu
Dukungan zona waktu: Dukungan kelas satu untuk semua zona waktu, termasuk aritmatika yang aman dari DST
Beberapa sistem kalender: Dukungan untuk kalender non-Gregorian
Presisi: Presisi nanodetik untuk perhitungan waktu
Konsistensi: Penguraian dan pemformatan standar

Jenis Data Utama dalam Temporal API

Temporal API memperkenalkan beberapa kelas khusus untuk menangani berbagai aspek tanggal dan waktu:

Jenis Data Plain (Tanpa Informasi Zona Waktu)

Temporal.PlainDate: Mewakili tanggal kalender (misalnya, 24 Agustus 2006) tanpa informasi waktu atau zona waktu
Temporal.PlainTime: Mewakili waktu jam dinding (misalnya, 19:39) tanpa tanggal atau zona waktu
Temporal.PlainDateTime: Menggabungkan tanggal dan waktu jam dinding tanpa informasi zona waktu
Temporal.PlainYearMonth: Mewakili tahun dan bulan tertentu (misalnya, Oktober 2020)
Temporal.PlainMonthDay: Mewakili bulan dan hari tanpa tahun (misalnya, 14 Juli)

Jenis Data Zoned (Dengan Informasi Zona Waktu)

Temporal.ZonedDateTime: Objek tanggal/waktu yang sadar zona waktu dan kalender yang mewakili peristiwa nyata pada waktu tertentu dari perspektif wilayah tertentu
Temporal.Instant: Mewakili titik waktu yang tetap (waktu yang tepat), tanpa memperhatikan kalender atau lokasi

Jenis Tambahan

Temporal.Duration: Mengekspresikan durasi waktu (misalnya, 5 menit dan 30 detik)
Temporal.TimeZone: Mewakili zona waktu dan menyediakan metode konversi
Temporal.Calendar: Mewakili sistem kalender

Bekerja dengan Temporal API

Membuat Objek Temporal

Temporal API menyediakan beberapa cara untuk membuat objek:

// Mendapatkan tanggal dan waktu saat ini
const now = Temporal.Now.plainDateTimeISO();
console.log(now.toString()); // misalnya, 2023-08-24T14:30:45.123456789

// Hanya tanggal
const today = Temporal.Now.plainDateISO();
console.log(today.toString()); // misalnya, 2023-08-24

// Hanya waktu
const currentTime = Temporal.Now.plainTimeISO();
console.log(currentTime.toString()); // misalnya, 14:30:45.123456789

// Membuat objek dari komponen
const date = Temporal.PlainDate.from({ year: 2023, month: 8, day: 24 });
const time = Temporal.PlainTime.from({ hour: 14, minute: 30, second: 45 });
const dateTime = Temporal.PlainDateTime.from({
  year: 2023,
  month: 8,
  day: 24,
  hour: 14,
  minute: 30,
  second: 45
});

// Membuat dari string ISO
const dateFromString = Temporal.PlainDate.from("2023-08-24");
const timeFromString = Temporal.PlainTime.from("14:30:45");
const dateTimeFromString = Temporal.PlainDateTime.from("2023-08-24T14:30:45");

Bekerja dengan Zona Waktu

Temporal API membuat bekerja dengan zona waktu menjadi lebih mudah:

// Waktu saat ini di zona waktu lokal
const localTime = Temporal.Now.zonedDateTimeISO();
console.log(localTime.toString()); 
// misalnya, 2023-08-24T14:30:45+01:00[Europe/London]

// Waktu saat ini di zona waktu tertentu
const tokyoTime = Temporal.Now.zonedDateTimeISO("Asia/Tokyo");
console.log(tokyoTime.toString()); 
// misalnya, 2023-08-24T22:30:45+09:00[Asia/Tokyo]

// Mengonversi antar zona waktu
const nyTime = localTime.withTimeZone("America/New_York");
console.log(nyTime.toString()); 
// misalnya, 2023-08-24T09:30:45-04:00[America/New_York]

Aritmatika Tanggal dan Waktu

Salah satu fitur paling kuat dari Temporal API adalah operasi aritmatika intuitifnya:

// Menambahkan waktu
const tomorrow = today.add({ days: 1 });
const nextWeek = today.add({ days: 7 });
const twoHoursLater = currentTime.add({ hours: 2 });

// Mengurangi waktu
const yesterday = today.subtract({ days: 1 });
const lastWeek = today.subtract({ days: 7 });
const twoHoursEarlier = currentTime.subtract({ hours: 2 });

// Bekerja dengan durasi
const duration = Temporal.Duration.from({ hours: 2, minutes: 30 });
const laterTime = currentTime.add(duration);

// Mencari perbedaan antara dua tanggal
const date1 = Temporal.PlainDate.from("2023-01-01");
const date2 = Temporal.PlainDate.from("2023-08-24");
const difference = date1.until(date2);
console.log(difference.toString()); // P236D (format durasi ISO 8601)
console.log(difference.days); // 236

Memodifikasi Komponen dengan "with"

Temporal API menyediakan cara yang bersih untuk membuat objek baru dengan komponen yang dimodifikasi:

// Mengubah tahun suatu tanggal
const nextYear = date.with({ year: date.year + 1 });

// Menetapkan komponen tertentu
const newDateTime = dateTime.with({ hour: 12, minute: 0, second: 0 });
console.log(newDateTime.toString()); // 2023-08-24T12:00:00

Membandingkan Objek Temporal

API menyediakan metode perbandingan intuitif:

const date1 = Temporal.PlainDate.from("2023-08-24");
const date2 = Temporal.PlainDate.from("2023-09-15");

console.log(date1.equals(date2)); // false
console.log(date1.equals(date1)); // true
console.log(date1.before(date2)); // true
console.log(date1.after(date2)); // false
console.log(date1.since(date2).days); // -22

Menangani DST dan Waktu yang Ambigu

Temporal API dengan elegan menangani kompleksitas transisi Waktu Musim Panas:

// Membuat waktu yang jatuh selama transisi DST
const dstTime = Temporal.ZonedDateTime.from({
  timeZone: "America/New_York",
  year: 2023,
  month: 11,
  day: 5,
  hour: 1,
  minute: 30
});

// API memungkinkan Anda menentukan cara menangani waktu yang ambigu
const dstTimeExact = Temporal.ZonedDateTime.from({
  timeZone: "America/New_York",
  year: 2023,
  month: 11,
  day: 5,
  hour: 1,
  minute: 30,
  disambiguation: "earlier" // Opsi: 'earlier', 'later', 'compatible', 'reject'
});

Dukungan untuk Kalender Non-Gregorian

Tidak seperti objek Date, Temporal API mendukung beberapa sistem kalender:

// Membuat tanggal dalam kalender Ibrani
const hebrewDate = Temporal.PlainDate.from({
  year: 5783,
  month: 5,
  day: 15,
  calendar: "hebrew"
});

// Mengonversi antar sistem kalender
const gregorianDate = hebrewDate.withCalendar("iso8601");

Penguraian dan Pemformatan

Temporal API menyediakan metode bawaan untuk penguraian dan pemformatan:

// Mengurai dari string
const date = Temporal.PlainDate.from("2023-08-24");

// Pemformatan khusus
const options = {
  year: 'numeric',
  month: 'long',
  day: 'numeric'
};
console.log(date.toLocaleString("en-US", options)); // August 24, 2023

Status Saat Ini dan Dukungan Browser

Saat penulisan, Temporal API berada pada Tahap 3 dalam proses proposal TC39, yang berarti hampir selesai tetapi belum menjadi bagian dari standar ECMAScript resmi. Meskipun dukungan browser asli masih tertunda, pengembang dapat menggunakan polyfill seperti @js-temporal/polyfill untuk mulai menggunakan API ini hari ini:

// Memasang polyfill
// npm install @js-temporal/polyfill

// Menggunakan dalam kode Anda
import { Temporal } from "@js-temporal/polyfill";

const now = Temporal.Now.plainDateTimeISO();

Kesimpulan

Temporal API mewakili peningkatan signifikan dalam kemampuan penanganan tanggal dan waktu JavaScript. Dengan mengatasi masalah lama dengan objek Date dan menyediakan API yang komprehensif dan intuitif, ia berjanji untuk membuat bekerja dengan konsep temporal di JavaScript jauh lebih menyenangkan dan tidak rentan terhadap kesalahan.

Manfaat utama Temporal API meliputi:

Imutabilitas: Semua operasi mengembalikan objek baru, mencegah efek samping
Kejelasan: Perbedaan yang jelas antara berbagai jenis tanggal dan waktu
Komprehensif: Mencakup segalanya mulai dari tanggal sederhana hingga operasi sadar zona waktu yang kompleks
Intuitif: Metode seperti add(), subtract(), dan with() membuat operasi umum menjadi mudah
Presisi: Mendukung presisi nanodetik
Global: Dukungan untuk beberapa zona waktu dan sistem kalender

Sambil menunggu browser untuk mengimplementasikan API ini secara asli, polyfill memungkinkan pengembang untuk mulai mendapatkan manfaat dari peningkatan ini hari ini. Karena aplikasi web terus menjadi lebih global dan sensitif terhadap waktu, Temporal API pasti akan menjadi alat penting dalam setiap toolkit pengembang JavaScript, yang akhirnya mengakhiri kebutuhan akan pustaka eksternal untuk operasi tanggal dan waktu dasar.

Dengan merangkul Temporal API, pengembang dapat menulis kode yang lebih bersih dan lebih mudah dipelihara yang menangani kompleksitas tanggal, waktu, dan zona waktu dengan benar, yang menghasilkan pengalaman pengguna yang lebih baik di seluruh dunia.

button