[dependencies]
chrono = "0.4"  # 穩(wěn)定版，生態(tài)兼容度最高

[dependencies]
chrono = { version = "0.4", features = ["serde", "tzdb"] }
# serde：支持日期時間類型的序列化/反序列化
# tzdb：包含完整時區(qū)數(shù)據(jù)庫（如 Asia/Shanghai、America/New_York）

use chrono::{NaiveDate, NaiveTime, NaiveDateTime};
fn main() {
    // 1. 創(chuàng)建 NaiveDate（年-月-日）
    let date = NaiveDate::from_ymd_opt(2026, 1, 12).unwrap();
    println!("NaiveDate：{}", date);  // 輸出：2026-01-12
    // 2. 創(chuàng)建 NaiveTime（時:分:秒.納秒）
    let time = NaiveTime::from_hms_nano_opt(14, 30, 45, 123456789).unwrap();
    println!("NaiveTime：{}", time);  // 輸出：14:30:45.123456789
    // 3. 組合為 NaiveDateTime
    let dt = NaiveDateTime::new(date, time);
    println!("NaiveDateTime：{}", dt);  // 輸出：2026-01-12T14:30:45.123456789
    // 4. 從字符串解析 NaiveDateTime（指定格式）
    let dt_str = "2026-01-12 14:30:45";
    let parsed_dt = NaiveDateTime::parse_from_str(dt_str, "%Y-%m-%d %H:%M:%S").unwrap();
    println!("解析后的 NaiveDateTime：{}", parsed_dt);
}

use chrono::{DateTime, Local, Utc, TimeZone};
// 開啟 tzdb 特性后可引入自定義時區(qū)
use chrono_tz::Asia::Shanghai;
fn main() {
    // 1. 獲取當前 UTC 時間
    let utc_now: DateTime<Utc> = Utc::now();
    println!("當前 UTC 時間：{}", utc_now);  // 輸出：2026-01-12T06:30:45.123456789Z（Z 表示 UTC）
    // 2. 獲取當前本地時間
    let local_now: DateTime<Local> = Local::now();
    println!("當前本地時間：{}", local_now);  // 輸出：2026-01-12T14:30:45.123456789+08:00（+08:00 表示時區(qū)偏移）
    // 3. 獲取指定時區(qū)當前時間（需 tzdb 特性）
    let shanghai_now: DateTime<chrono_tz::Tz> = Shanghai::now();
    println!("上海當前時間：{}", shanghai_now);  // 輸出：2026-01-12T14:30:45.123456789+08:00
    // 4. 將 NaiveDateTime 綁定到指定時區(qū)
    let naive_dt = NaiveDateTime::from_ymd_hms_opt(2026, 1, 12, 14, 30, 45).unwrap();
    let shanghai_dt = Shanghai.from_local_datetime(&naive_dt).unwrap();
    println!("綁定時區(qū)后的時間：{}", shanghai_dt);
}

use chrono::{Utc, Local};
fn main() {
    let utc_now = Utc::now();
    let local_now = Local::now();
    // 1. 格式化 UTC 時間（帶時區(qū)標識）
    let utc_format = utc_now.format("%Y-%m-%d %H:%M:%S.%f UTC").to_string();
    println!("格式化 UTC 時間：{}", utc_format);  // 輸出：2026-01-12 06:30:45.123456 UTC
    // 2. 格式化本地時間（帶星期、時區(qū)偏移）
    let local_format = local_now.format("%Y年%m月%d日 %A %H:%M:%S %z").to_string();
    println!("格式化本地時間：{}", local_format);  // 輸出：2026年01月12日 Sunday 14:30:45 +0800
    // 3. 簡潔格式（預定義風格，無需手動寫占位符）
    let iso_format = local_now.to_rfc3339();  // RFC3339 標準格式
    println!("RFC3339 格式：{}", iso_format);  // 輸出：2026-01-12T14:30:45.123456+08:00
}

use chrono::{DateTime, Utc, Local, NaiveDateTime};
use chrono_tz::Asia::Shanghai;
fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 解析無時區(qū)字符串為 NaiveDateTime
    let naive_str = "2026-01-12 14:30:45";
    let naive_dt = NaiveDateTime::parse_from_str(naive_str, "%Y-%m-%d %H:%M:%S")?;
    println!("解析無時區(qū)時間：{}", naive_dt);
    // 2. 解析帶時區(qū)字符串為 DateTime<Utc>
    let utc_str = "2026-01-12T06:30:45Z";  // Z 表示 UTC
    let utc_dt = DateTime::parse_from_rfc3339(utc_str)?.with_timezone(&Utc);
    println!("解析 UTC 時間：{}", utc_dt);
    // 3. 解析帶時區(qū)偏移的字符串為指定時區(qū)時間
    let sh_str = "2026-01-12 14:30:45 +08:00";
    let sh_dt = DateTime::parse_from_str(sh_str, "%Y-%m-%d %H:%M:%S %z")?
        .with_timezone(&Shanghai);
    println!("解析上海時區(qū)時間：{}", sh_dt);
    Ok(())
}

use chrono::{Local, Duration};
fn main() {
    let now = Local::now();
    println!("當前時間：{}", now);
    // 1. 時間加減（Duration 支持天、時、分、秒、納秒）
    let one_hour_later = now + Duration::hours(1);
    let two_days_ago = now - Duration::days(2);
    println!("1小時后：{}", one_hour_later);
    println!("2天前：{}", two_days_ago);
    // 2. 計算兩個時間的差值
    let diff = one_hour_later - now;
    println!("時間差：{} 秒", diff.num_seconds());  // 輸出：3600
    println!("時間差：{} 分鐘", diff.num_minutes());  // 輸出：60
    // 3. 時間大小比較
    println!("1小時后是否晚于當前時間：{}", one_hour_later > now);  // true
    println!("2天前是否早于當前時間：{}", two_days_ago < now);  // true
    println!("當前時間是否等于自身：{}", now == now);  // true
    // 4. 取整操作（截斷到指定單位）
    let truncated = now.trunc_subsecs(0);  // 截斷納秒，保留到秒
    println!("截斷到秒的時間：{}", truncated);  // 輸出：2026-01-12T14:30:45+08:00
}

use chrono::{DateTime, Utc};
use chrono_tz::{Asia::Shanghai, America::New_York, Europe::London};
fn main() {
    // 獲取當前 UTC 時間（全球統(tǒng)一基準）
    let utc_now = Utc::now();
    println!("UTC 時間：{}", utc_now);
    // 轉換為上海時區(qū)（UTC+8）
    let shanghai_dt = utc_now.with_timezone(&Shanghai);
    println!("上海時間：{}", shanghai_dt);
    // 轉換為紐約時區(qū)（UTC-5 或 UTC-4，夏令時變化）
    let new_york_dt = utc_now.with_timezone(&New_York);
    println!("紐約時間：{}", new_york_dt);
    // 轉換為倫敦時區(qū)（UTC+0 或 UTC+1，夏令時變化）
    let london_dt = utc_now.with_timezone(&London);
    println!("倫敦時間：{}", london_dt);
    // 不同時區(qū)時間互轉
    let ny_to_sh = new_york_dt.with_timezone(&Shanghai);
    println!("紐約時間轉上海時間：{}", ny_to_sh);
}

use chrono::{DateTime, Utc, Local};
use serde::{Serialize, Deserialize};
use serde_json;
// 定義包含日期時間的結構體
#[derive(Debug, Serialize, Deserialize)]
struct Event {
    name: String,
    // 序列化時默認使用 RFC3339 格式
    utc_time: DateTime<Utc>,
    local_time: DateTime<Local>,
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let event = Event {
        name: "技術分享會".to_string(),
        utc_time: Utc::now(),
        local_time: Local::now(),
    };
    // 序列化為 JSON 字符串
    let json_str = serde_json::to_string_pretty(&event)?;
    println!("序列化后的 JSON：\n{}", json_str);
    // 反序列化 JSON 字符串為結構體
    let deserialized_event: Event = serde_json::from_str(&json_str)?;
    println!("反序列化后的事件：{:?}", deserialized_event);
    Ok(())
}

use chrono::{Local, Duration};
use tokio::time;
#[tokio::main]
async fn main() {
    println!("定時任務啟動時間：{}", Local::now());
    // 每隔 2 秒執(zhí)行一次任務（結合 Chrono 的 Duration）
    let mut interval = time::interval(Duration::seconds(2).into());
    loop {
        interval.tick().await;
        println!("定時任務執(zhí)行時間：{}", Local::now());
    }
}

use chrono::Local;
use log::{info, warn};
use env_logger::{Builder, Env};
fn main() {
    // 配置日志格式，加入 Chrono 格式化的時間戳
    Builder::from_env(Env::default().default_filter_or("info"))
        .format(|buf, record| {
            let now = Local::now().format("%Y-%m-%d %H:%M:%S.%f").to_string();
            writeln!(
                buf,
                "[{}] [{}] {}",
                now,
                record.level(),
                record.args()
            )
        })
        .init();
    info!("程序啟動成功");
    warn!("注意：即將執(zhí)行敏感操作");
    info!("操作執(zhí)行完成");
}