unisbadri.com » Python Java Golang Typescript Kotlin Ruby Rust Dart PHP
Date & Time

Date & Time #

Pengelolaan tanggal dan waktu (datetime) adalah kebutuhan umum dalam banyak aplikasi, seperti saat mencatat waktu pembuatan dokumen, menghitung durasi, atau mengatur pengingat. Di Rust, DateTime dan operasi terkait tanggal dan waktu dapat diimplementasikan menggunakan crate pihak ketiga yang populer, yaitu chrono. Crate chrono menyediakan berbagai tipe dan fungsi untuk menangani tanggal, waktu, zona waktu, dan durasi dengan cara yang efisien dan fleksibel.

Menggunakan Crate chrono #

Untuk mulai bekerja dengan DateTime di Rust, Anda perlu menambahkan crate chrono ke dalam proyek Anda. Anda dapat melakukannya dengan menambahkan dependensi ini ke file Cargo.toml:

[dependencies]
chrono = "0.4"

Setelah itu, Anda bisa mulai menggunakan crate chrono untuk bekerja dengan tanggal dan waktu.

DateTime, Date, dan Time #

Crate chrono menyediakan tipe data utama berikut untuk menangani tanggal dan waktu:

  • DateTime<Tz>: Representasi dari tanggal dan waktu dalam zona waktu tertentu (Tz). Tipe ini adalah yang paling umum digunakan untuk mencatat waktu secara lengkap (tanggal + waktu).
  • Date<Tz>: Representasi dari tanggal saja tanpa waktu, tapi dengan informasi zona waktu.
  • NaiveDateTime: Representasi dari tanggal dan waktu tanpa informasi zona waktu.
  • NaiveDate: Representasi dari tanggal saja tanpa informasi zona waktu.
  • NaiveTime: Representasi dari waktu saja tanpa informasi tanggal dan zona waktu.

Membuat DateTime #

Anda dapat membuat DateTime menggunakan beberapa cara, tergantung pada kebutuhan aplikasi Anda.

Mendapatkan Waktu Sekarang #

Anda dapat memperoleh waktu saat ini dengan menggunakan fungsi Utc::now() atau Local::now() yang akan mengembalikan waktu dalam zona waktu UTC atau lokal.

Contoh:

use chrono::prelude::*;

fn main() {
    let utc_now: DateTime<Utc> = Utc::now();
    let local_now: DateTime<Local> = Local::now();

    println!("UTC now: {}", utc_now);
    println!("Local now: {}", local_now);
}

Penjelasan:

  • Utc::now() mengembalikan waktu saat ini dalam UTC (Coordinated Universal Time).
  • Local::now() mengembalikan waktu saat ini dalam zona waktu lokal.

Membuat DateTime dari Tanggal dan Waktu Tertentu #

Anda juga dapat membuat DateTime dari tanggal dan waktu tertentu menggunakan metode chrono::NaiveDate dan chrono::NaiveTime.

Contoh:

use chrono::prelude::*;

fn main() {
    let naive_date = NaiveDate::from_ymd(2024, 8, 24);
    let naive_time = NaiveTime::from_hms(12, 30, 45);
    let naive_datetime = NaiveDateTime::new(naive_date, naive_time);

    let datetime: DateTime<Utc> = DateTime::from_utc(naive_datetime, Utc);

    println!("Naive datetime: {}", naive_datetime);
    println!("UTC datetime: {}", datetime);
}

Penjelasan:

  • NaiveDate::from_ymd membuat objek tanggal tanpa zona waktu.
  • NaiveTime::from_hms membuat objek waktu tanpa zona waktu.
  • NaiveDateTime::new menggabungkan tanggal dan waktu menjadi NaiveDateTime.
  • DateTime::from_utc mengkonversi NaiveDateTime menjadi DateTime<Utc> dengan menambahkan informasi zona waktu.

Operasi pada DateTime #

Anda dapat melakukan berbagai operasi pada DateTime seperti perhitungan selisih waktu, penambahan atau pengurangan durasi, serta manipulasi lainnya.

Menambahkan dan Mengurangi Durasi #

Anda dapat menambahkan atau mengurangi durasi dari DateTime menggunakan tipe chrono::Duration.

Contoh:

use chrono::prelude::*;
use chrono::Duration;

fn main() {
    let utc_now: DateTime<Utc> = Utc::now();

    // Tambahkan 1 hari
    let tomorrow = utc_now + Duration::days(1);

    // Kurangi 2 jam
    let two_hours_ago = utc_now - Duration::hours(2);

    println!("Sekarang: {}", utc_now);
    println!("Besok: {}", tomorrow);
    println!("Dua jam yang lalu: {}", two_hours_ago);
}

Penjelasan:

  • Duration::days mengembalikan durasi dalam satuan hari.
  • Duration::hours mengembalikan durasi dalam satuan jam.
  • Operator + dan - digunakan untuk menambahkan atau mengurangi durasi dari DateTime.

Menghitung Selisih antara Dua DateTime #

Anda bisa menghitung selisih antara dua DateTime menggunakan metode signed_duration_since, yang mengembalikan objek Duration.

Contoh:

use chrono::prelude::*;
use chrono::Duration;

fn main() {
    let earlier = Utc.ymd(2024, 8, 23).and_hms(12, 0, 0);
    let later = Utc.ymd(2024, 8, 24).and_hms(12, 0, 0);

    let duration = later.signed_duration_since(earlier);

    println!("Durasi antara dua waktu: {} jam", duration.num_hours());
}

Penjelasan:

  • signed_duration_since menghitung durasi antara dua DateTime.
  • num_hours mengkonversi durasi ke dalam satuan jam.

Membandingkan DateTime #

Anda dapat membandingkan dua objek DateTime menggunakan operator perbandingan biasa (==, !=, <, <=, >, >=).

Contoh:

use chrono::prelude::*;

fn main() {
    let datetime1 = Utc.ymd(2024, 8, 24).and_hms(12, 0, 0);
    let datetime2 = Utc.ymd(2024, 8, 24).and_hms(14, 0, 0);

    if datetime1 < datetime2 {
        println!("datetime1 lebih awal dari datetime2");
    } else {
        println!("datetime1 tidak lebih awal dari datetime2");
    }
}

Penjelasan:

  • Operator perbandingan digunakan untuk membandingkan dua objek DateTime.

Parsing dan Format DateTime #

Crate chrono juga menyediakan kemampuan untuk memformat dan memparsing DateTime ke dan dari string.

Memformat DateTime ke String #

Anda dapat memformat DateTime ke dalam string menggunakan metode format.

Contoh:

use chrono::prelude::*;

fn main() {
    let datetime = Utc.ymd(2024, 8, 24).and_hms(12, 30, 45);
    let formatted = datetime.format("%Y-%m-%d %H:%M:%S").to_string();
    println!("Waktu terformat: {}", formatted);
}

Penjelasan:

  • format memungkinkan Anda untuk mengonversi DateTime menjadi string dengan format khusus, misalnya "%Y-%m-%d %H:%M:%S" untuk format YYYY-MM-DD HH:MM:SS.

Parsing String ke DateTime #

Anda dapat memparsing string menjadi DateTime menggunakan metode chrono::DateTime::parse_from_str atau chrono::NaiveDateTime::parse_from_str jika string tidak mengandung informasi zona waktu.

Contoh:

use chrono::prelude::*;

fn main() {
    let datetime_str = "2024-08-24 12:30:45";
    let datetime = NaiveDateTime::parse_from_str(datetime_str, "%Y-%m-%d %H:%M:%S")
        .expect("Parsing gagal");
    
    println!("DateTime hasil parsing: {}", datetime);
}

Penjelasan:

  • parse_from_str mencoba memparsing string berdasarkan format yang diberikan, dan mengembalikan Result yang harus Anda tangani (menggunakan expect atau match).

Konversi Zona Waktu #

Anda dapat mengonversi DateTime dari satu zona waktu ke zona waktu lain menggunakan metode with_timezone.

Contoh:

use chrono::prelude::*;
use chrono::TimeZone;

fn main() {
    let utc_now: DateTime<Utc> = Utc::now();
    let est_now: DateTime<FixedOffset> = utc_now.with_timezone(&FixedOffset::west(5 * 3600));

    println!("Waktu UTC: {}", utc_now);
    println!("Waktu EST: {}", est_now);
}

Penjelasan:

  • FixedOffset::west menggeser zona waktu ke barat (misalnya, EST adalah UTC-5 jam).
  • with_timezone mengubah DateTime ke zona waktu yang diberikan.

Kesimpulan #

Rust, dengan bantuan crate chrono, menyediakan alat yang sangat kuat dan fleksibel untuk bekerja dengan tanggal dan waktu. Anda dapat membuat, memanipulasi, memformat, dan memparsing DateTime dengan mudah, serta menangani berbagai operasi umum seperti penambahan durasi, perbandingan, dan konversi zona waktu. Dengan memahami cara menggunakan chrono, Anda dapat mengelola waktu dan tanggal dalam aplikasi Rust Anda dengan cara yang efisien dan aman.

« Map
Regex »