Bekerja Dengan Tanggal dan Waktu di Rust

Menangani tanggal dan waktu adalah aspek penting dari banyak aplikasi, mulai dari menjadwalkan tugas dan menganalisis data hingga melakukan penghitungan dan memastikan representasi data.

Rust memiliki banyak pustaka dan modul untuk bekerja dengan tanggal dan waktu. Rust menyediakan built-in waktu peti untuk operasi terkait waktu, dan perpustakaan Chrono berinteroperasi dengan banyak perpustakaan Rust lainnya untuk operasi tanggal dan waktu.

Memulai Bekerja Dengan Tanggal dan Waktu di Rust

Chrono adalah perpustakaan tanggal-waktu untuk menangani tanggal, waktu, zona waktu, dan durasi di Rust. Chrono menyediakan banyak fitur dan API intuitif untuk jenis tanggal dan waktu, zona waktu dan offset tanggal-waktu, durasi dan interval, penguraian dan pemformatan, dan bekerja dengan kalender.

Chrono bekerja dengan baik dengan perpustakaan lain di ekosistem Rust dan berintegrasi mulus dengan standar sifat I/O perpustakaan memungkinkan Anda membaca dan menulis nilai tanggal dan waktu Chrono dari dan ke berbagai sungai.

Selain itu, Chrono memiliki dukungan untuk serialisasi dan deserialisasi melalui Serde peti, membuatnya mudah untuk bekerja dengan tipe Chrono di JSON, YAML, dan format lainnya. Integrasi Chrono dengan Serde membuatnya cocok untuk operasi tanggal-waktu sementara membangun aplikasi web di Rust.

Anda dapat menggunakan Chrono untuk mengambil lokasi Anda UTC (Waktu Universal Terkoordinasi) untuk berbagai operasi seperti konversi.

Tambahkan arahan ini ke dependencies bagian Anda Kargo.toml file untuk menginstal dan menggunakan krono peti:

[ketergantungan]
krono = "0.4.24"

Setelah menginstal krono peti, Anda dapat menggunakan krono dalam proyek Rust Anda dengan mengimpor peti sebagai berikut:

menggunakan chrono:: pendahuluan::*;

Chrono adalah salah satu peti Rust yang Anda perlukan di gudang pengembangan karena Chrono menyediakan sebagian besar fitur untuk operasi tanggal dan waktu.

Zona Waktu dan Penanganan Waktu di Rust With Chrono

Zona waktu memastikan bahwa stempel waktu dan informasi terkait waktu akurat dan konsisten di berbagai lokasi geografis. Saat bekerja dengan data terkait waktu, penting untuk mempertimbangkan zona waktu untuk mencegah ambiguitas dan ketidakakuratan. Operasi seperti membandingkan stempel waktu, menghitung durasi, atau menjadwalkan acara tanpa penanganan zona waktu yang tepat dapat memberikan hasil yang tidak terduga.

Anda dapat mengonversi antar zona waktu dengan Chrono. Berikut adalah contoh konversi a Tanggal Waktu dari satu zona waktu ke zona waktu lainnya:

menggunakan chrono::{DateTime, Utc, Local, TimeZone};
fnconvert_timezone() {
membiarkan utc_time: TanggalWaktu = Utc:: sekarang();
membiarkan waktu_lokal: TanggalWaktu = utc_time.with_timezone(&Lokal);
cetak!("Waktu UTC: {}", waktu_utc);
cetak!("Waktu lokal: {}", waktu lokal);
}

Itu convert_timezone fungsi mengambil UTC saat ini dengan Utc:: sekarang metode, mengonversi UTC ke zona waktu lokal dengan with_timezone metode yang mengacu pada Lokal struct dan mengembalikan a Tanggal Waktu objek yang mewakili titik waktu yang sama tetapi dalam zona waktu lokal.

Ketika Anda menelepon convert_timezone berfungsi, itu akan mencetak UTC dan waktu lokal ke konsol.

Selain itu, Chrono menyediakan metode dan fungsi yang nyaman untuk Daylight saving time (DST) dan offset zona waktu. Di sistem Anda, Anda bisa sesuaikan jam untuk Daylight saving time melalui aplikasi Pengaturan atau Panel Kontrol.

Berikut adalah contoh yang menunjukkan kemampuan Chrono dengan DST dan waktu offset:

menggunakan chrono::{DateTime, Utc, FixedOffset};
fnhandle_dst() {
membiarkan utc_time: TanggalWaktu = Utc:: sekarang();
membiarkan ny_timezone = FixedOffset:: timur(5 * 3600); 
// Waktu Musim Panas Bagian Timur (EDT) UTC-4:00 
membiarkan ny_time: DateTime = utc_time.with_timezone(&ny_timezone);
cetak!("Waktu UTC: {}", waktu_utc);
cetak!("Waktu New York: {}", ny_time);
}

Itu handle_dst fungsi mengakses waktu saat ini dengan Sekarang metode dan mengambil waktu di New York sambil memperhitungkan waktu offset dengan FixedOffset:: timur metode.

Dengan memanggil with_timezone fungsi, Anda mengonversi UTC ke zona waktu New York. Chrono menangani penyesuaian waktu sesuai dengan DST yang sesuai dan mengembalikan a Tanggal Waktu obyek.

Saat mengoperasikan DST, penting untuk diingat bahwa transisi DST terjadi pada tanggal dan waktu tertentu. milik Chrono Tanggal Waktu struct dilengkapi untuk menangani transisi ini dan memastikan representasi waktu yang akurat di zona waktu yang berbeda.

Perhitungan Durasi dan Interval

Durasi adalah waktu yang tidak bergantung pada titik waktu tertentu. Anda mungkin perlu menghitung durasi antara dua peristiwa, mengukur waktu yang berlalu, atau menambah atau mengurangi jumlah tertentu dari waktu yang ditentukan.

Pustaka standar Rust waktu peti menyediakan alat yang komprehensif untuk menangani durasi secara efisien.

Inilah cara Anda dapat mengukur waktu eksekusi suatu fungsi dengan waktu peti:

menggunakan chrono::{DateTime, Utc};
menggunakan std:: waktu:: Instan;
fnutama() {
membiarkan mulai = Instan:: sekarang();
// Melakukan beberapa operasi
// ...
membiarkan end = Instan:: sekarang();
membiarkan durasi = akhir.durasi_sejak (mulai);
cetak!("Waktu berlalu: {:?}", durasi);
}

Itu utama fungsi mengambil waktu saat ini dengan Instan metode built-in waktu peti. Setelah operasi, utama fungsi mengambil waktu pada saat itu dan mengevaluasi perbedaan dengan durasi_sejak berfungsi sebelum mencetak perbedaan waktu ke konsol.

Serialisasi dan Deserialisasi: Mengonversi Tanggal dan Waktu JSON ke Struktur Rust Menggunakan Chrono

Serialisasi dan deserialisasi nilai tanggal dan waktu dari JSON menggunakan Chrono dan Serde adalah proses yang mudah. Pertama, tambahkan serde Dan serde_json peti ke dependensi proyek Anda.

[ketergantungan]
serde = { versi = "1.0", fitur = ["memperoleh"] }
serde_json = "1.0"

Selanjutnya, Anda harus menentukan jenis Rust dan mengimplementasikannya #[turunkan (Serialisasikan, Deserialisasikan)] atribut untuk tipe tempat Anda akan menentukan tipe data:

menggunakan chrono::{DateTime, Utc};
#[turunkan (Serialisasikan, Deserialisasikan)]
structPertemuan {
 waktu_mulai: TanggalWaktu,
 waktu_akhir: TanggalWaktu,
}

Anda dapat membuat serial Pertemuan struct ke JSON dengan Serde di samping kemampuan pemformatan Chrono.

Inilah cara Anda dapat mengonversi instance dari Pertemuan ketik ke JSON:

menggunakan serde_json:: ke_string;
fnutama() {
membiarkan rapat = Rapat {
 waktu_mulai: Utc:: sekarang(),
 waktu_akhir: Utc:: sekarang(),
 };
membiarkan json = to_string(&meeting).unwrap();
cetak!("{}", json);
}

Itu utama fungsi menciptakan a Pertemuan Misalnya dengan UTC saat ini untuk bidang sebelum menggunakan to_string berfungsi untuk mengubah instance struct menjadi string JSON yang dicetak ke konsol.

Anda dapat dengan mudah melakukan deserialisasi data tanggal-waktu JSON menjadi tipe struct dengan serde_json from_str fungsi yang mengambil string JSON dan mengembalikan instance struct.

menggunakan serde_json:: from_str;
fnutama() {
membiarkan json = r#"{"start_time": "2023-05-28T12:00:00Z", "end_time": "2023-05-28T14:00:00Z"}"#;
membiarkan rapat: Rapat = from_str (json).unwrap();
cetak!("{:#?}", pertemuan);
}

Itu utama fungsi deserializes string JSON dari json variabel ke dalam pertemuan contoh dari Pertemuan struct sebelum mencetak instance struct ke konsol.

Anda Dapat Membangun Aplikasi Canggih Dengan Karat

Kekokohan Chrono, kemudahan penggunaan, dan fungsionalitas yang ekstensif menjadikannya alat yang sangat diperlukan untuk menangani tanggal, waktu, durasi, dan interval aplikasi Anda. Anda dapat memastikan penghitungan waktu yang akurat, penjadwalan yang efisien, dan operasi terkait tanggal yang andal dengan memanfaatkan kemampuan Chrono.

Salah satu kasus penggunaan utama untuk Chrono adalah dalam membuat aplikasi web. Anda dapat menggunakan Chrono untuk merekam waktu aktivitas, mengatur waktu aktivitas pengguna, dan operasi web lainnya.