Rust के लिए chrono लाइब्रेरी: डेट और टाइम के साथ काम करने की पूर्ण गाइड

1. यह क्या है और क्यों ज़रूरी है

chrono लाइब्रेरी Rust इकोसिस्टम में डेट और टाइम के साथ काम करने का डी-फैक्टो स्टैंडर्ड है। यह पार्सिंग, फ़ॉर्मेटिंग, अरिथमेटिक और टाइमस्टैम्प मैनिपुलेशन के लिए एक शक्तिशाली, टाइप-सेफ और एर्गोनॉमिक API प्रदान करती है। Rust की स्टैंडर्ड लाइब्रेरी के विपरीत, जो केवल std::time के माध्यम से बुनियादी सुविधाएँ देती है (केवल ड्यूरेशन और सिस्टम टाइम के लिए), chrono डेवलपर की लगभग सभी ज़रूरतों को कवर करती है: टाइम ज़ोन से लेकर जटिल कैलेंडर गणनाओं तक।

यह क्यों ज़रूरी है? अगर आप कोई ऐसा एप्लिकेशन लिख रहे हैं जो जन्म तिथियों को प्रोसेस करता है, नैनोसेकंड सटीकता के साथ इवेंट लॉग करता है, शेड्यूल बनाता है या अंतरराष्ट्रीय टाइम ज़ोन के साथ काम करता है — तो chrono के बिना काम नहीं चलेगा। यह ISO 8601, RFC 2822, RFC 3339 फ़ॉर्मेट को सपोर्ट करती है, और कस्टम फ़ॉर्मेटर बनाने की भी सुविधा देती है। Rust की सख्त टाइप सिस्टम की बदौलत, chrono अमान्य डेट (जैसे 30 फरवरी) या UTC और लोकल टाइम के बीच भ्रम से होने वाली गलतियों से बचने में मदद करती है।

यह लाइब्रेरी कम्युनिटी द्वारा सक्रिय रूप से सपोर्ट की जाती है, इसकी बेहतरीन डॉक्यूमेंटेशन है, और इसका उपयोग हज़ारों प्रोजेक्ट्स में किया जाता है, जिनमें tokio, actix-web और diesel जैसे प्रसिद्ध प्रोजेक्ट शामिल हैं। वर्जन 0.4.x स्थिर है और प्रोडक्शन में उपयोग के लिए अनुशंसित है।

2. इंस्टॉलेशन

अपने Rust प्रोजेक्ट में chrono जोड़ने के लिए Cargo पैकेज मैनेजर का उपयोग करें। प्रोजेक्ट की रूट डायरेक्टरी में टर्मिनल में यह कमांड चलाएँ:

cargo add chrono

या मैन्युअल रूप से Cargo.toml फ़ाइल में डिपेंडेंसी जोड़ें:

[dependencies]
chrono = "0.4"

इसके बाद cargo build चलाएँ ताकि लाइब्रेरी और उसकी डिपेंडेंसी डाउनलोड हो जाएँ। टाइम ज़ोन के साथ काम करने के लिए (जैसे शहरों के नाम पार्स करना), serde या clock फीचर को सक्षम करना पड़ सकता है:

[dependencies]
chrono = { version = "0.4", features = ["serde"] }

3. त्वरित शुरुआत — न्यूनतम कार्यशील उदाहरण

main.rs फ़ाइल बनाएँ और नीचे दिया गया कोड डालें:

use chrono::{Local, Utc, DateTime, Duration};

fn main() {
    // UTC में वर्तमान समय
    let utc_now: DateTime = Utc::now();
    println!("वर्तमान UTC समय: {}", utc_now);

    // वर्तमान लोकल समय
    let local_now: DateTime = Local::now();
    println!("वर्तमान लोकल समय: {}", local_now);

    // डेट फ़ॉर्मेटिंग
    println!("फ़ॉर्मेटेड डेट: {}", local_now.format("%Y-%m-%d %H:%M:%S"));

    // अरिथमेटिक: 2 दिन जोड़ें
    let future = utc_now + Duration::days(2);
    println!("2 दिन बाद (UTC): {}", future);
}

प्रोग्राम को cargo run कमांड से चलाएँ। आपको UTC में वर्तमान समय, लोकल समय, फ़ॉर्मेटेड स्ट्रिंग और दो दिन बाद की तारीख दिखाई देगी।

4. मुख्य तरीके/फ़ंक्शन

नीचे chrono लाइब्रेरी के 8 मुख्य तरीके और टाइप दिए गए हैं। प्रत्येक के लिए सिग्नेचर, विवरण और कोड उदाहरण दिया गया है।

4.1. Utc::now()

सिग्नेचर: pub fn now() -> DateTime<Utc>

विवरण: UTC टाइम ज़ोन में वर्तमान समय लौटाता है। यह टाइमस्टैम्प प्राप्त करने का सबसे सुरक्षित तरीका है, क्योंकि यह सिस्टम के टाइम ज़ोन सेटिंग्स पर निर्भर नहीं करता।

use chrono::Utc;

fn main() {
    let now = Utc::now();
    println!("UTC में वर्तमान समय: {}", now);
    // आउटपुट: 2025-03-15 14:30:00.123456 UTC
}

4.2. Local::now()

सिग्नेचर: pub fn now() -> DateTime<Local>

विवरण: लोकल टाइम ज़ोन में वर्तमान समय लौटाता है। यह सिस्टम के टाइम ज़ोन सेटिंग्स का उपयोग करता है और उपयोगकर्ता के स्थानीय समय को दिखाने के लिए उपयोगी है।

use chrono::Local;

fn main() {
    let now = Local::now();
    println!("लोकल समय: {}", now);
    // आउटपुट: 2025-03-15 20:00:00.123456 +05:30
}

4.3. DateTime::format()

सिग्नेचर: pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>

विवरण: डेट और टाइम को एक स्ट्रिंग में फ़ॉर्मेट करता है। यह strftime फ़ॉर्मेट स्पेसिफायर का उपयोग करता है, जैसे %Y (साल), %m (महीना), %d (दिन), %H (घंटा), %M (मिनट), %S (सेकंड)।

use chrono::Utc;

fn main() {
    let now = Utc::now();
    let formatted = now.format("%d/%m/%Y %H:%M:%S");
    println!("फ़ॉर्मेटेड डेट: {}", formatted);
    // आउटपुट: 15/03/2025 14:30:00
}

4.4. NaiveDate::from_ymd()

सिग्नेचर: pub fn from_ymd(year: i32, month: u32, day: u32) -> NaiveDate

विवरण: साल, महीना और दिन देकर एक NaiveDate (बिना टाइम ज़ोन वाली तारीख) बनाता है। अगर तारीख अमान्य है (जैसे 30 फरवरी), तो यह पैनिक करेगा।

use chrono::NaiveDate;

fn main() {
    let date = NaiveDate::from_ymd(2025, 3, 15);
    println!("तारीख: {}", date);
    // आउटपुट: 2025-03-15
}

4.5. NaiveDateTime::parse_from_str()

सिग्नेचर: pub fn parse_from_str(input: &str, fmt: &str) -> ParseResult<NaiveDateTime>

विवरण: एक स्ट्रिंग को दिए गए फ़ॉर्मेट के अनुसार पार्स करके NaiveDateTime बनाता है। यह तब उपयोगी है जब आपको यूज़र इनपुट या फ़ाइल से डेट पढ़ना हो।

use chrono::NaiveDateTime;

fn main() {
    let date_str = "2025-03-15 14:30:00";
    let parsed = NaiveDateTime::parse_from_str(date_str, "%Y-%m-%d %H:%M:%S")
        .expect("पार्सिंग विफल");
    println!("पार्स की गई तारीख: {}", parsed);
    // आउटपुट: 2025-03-15 14:30:00
}

4.6. DateTime::checked_add_signed()

सिग्नेचर: pub fn checked_add_signed(self, rhs: OldDuration) -> Option<DateTime<Tz>>

विवरण: डेट और टाइम में एक ड्यूरेशन जोड़ता है और Option लौटाता है। अगर परिणाम मान्य है तो Some, अन्यथा None। यह ओवरफ़्लो या अमान्य तारीखों से बचाता है।

use chrono::{Utc, Duration};

fn main() {
    let now = Utc::now();
    let future = now.checked_add_signed(Duration::days(10));
    match future {
        Some(date) => println!("10 दिन बाद: {}", date),
        None => println!("अमान्य तारीख"),
    }
}

4.7. DateTime::timestamp()

सिग्नेचर: pub fn timestamp(&self) -> i64

विवरण: Unix टाइमस्टैम्प (1 जनवरी 1970 से सेकंड में) लौटाता है। यह टाइमस्टैम्प को सेव करने या अन्य सिस्टम के साथ इंटरऑपरेट करने के लिए उपयोगी है।

use chrono::Utc;

fn main() {
    let now = Utc::now();
    let ts = now.timestamp();
    println!("Unix टाइमस्टैम्प: {}", ts);
    // आउटपुट: 1742041800 (उदाहरण)
}

4.8. FixedOffset::east()

सिग्नेचर: pub fn east(seconds: i32) -> FixedOffset

विवरण: एक निश्चित टाइम ज़ोन ऑफ़सेट बनाता है (UTC से पूर्व की ओर सेकंड में)। यह कस्टम टाइम ज़ोन बनाने के लिए उपयोगी है, जैसे IST (UTC+5:30) के लिए।

use chrono::{FixedOffset, Utc};

fn main() {
    let ist_offset = FixedOffset::east(5 * 3600 + 30 * 60); // UTC+5:30
    let utc_now = Utc::now();
    let ist_now = utc_now.with_timezone(&ist_offset);
    println!("IST समय: {}", ist_now);
    // आउटपुट: 2025-03-15 20:00:00 +05:30
}

5. निष्कर्ष

chrono Rust में डेट और टाइम हैंडलिंग के लिए सबसे शक्तिशाली और लोकप्रिय लाइब्रेरी है। इस गाइड में हमने इंस्टॉलेशन, बुनियादी उपयोग और मुख्य तरीकों को उदाहरणों के साथ कवर किया है। अब आप अपने Rust प्रोजेक्ट्स में डेट और टाइम के साथ आसानी से काम कर सकते हैं। अधिक जानकारी के लिए आधिकारिक डॉक्यूमेंटेशन देखें और अपने कोड में chrono का उपयोग करके अभ्यास करें।