Elysia Tools

Browse tools, examples, visual explainers, and topic guides from one clear workspace.

Top Categories

Hubs

Language
ZHDERUPTENFRES

Elysia Tools

Navigation

Rust

Web Date & Time Rust Samples

Web Rust date and time handling examples including getting current time, formatting, and parsing

Samples

Entries inside this sample collection

CoderustSimple

Get Current Time

Retrieve system current time in various formats using chrono crate

Difficulty

3/10

Estimated time

15 min

Tags

rust, web, datetime

Prerequisites

Basic Rust, chrono crate

rust
// Web Rust Get Current Time Examples
// Working with current time using chrono crate
//
// Add to Cargo.toml:
// [dependencies]
// chrono = "0.4"

use chrono::{Datelike, DateTime, Local, Local as DateTimeLocal, Timelike, Utc};

// 1. Get Current Time (UTC)

/// Get current UTC time as DateTime
fn get_current_utc() -> DateTime<Utc> {
    Utc::now()
}

/// Get current UTC timestamp (seconds since epoch)
fn get_current_timestamp() -> i64 {
    Utc::now().timestamp()
}

/// Get current UTC timestamp (milliseconds since epoch)
fn get_current_timestamp_millis() -> i64 {
    Utc::now().timestamp_millis()
}

/// Get current UTC timestamp (microseconds since epoch)
fn get_current_timestamp_micros() -> i64 {
    Utc::now().timestamp_micros()
}

// 2. Get Current Time (Local)

/// Get current local time
fn get_current_local() -> DateTime<DateTimeLocal> {
    Local::now()
}

/// Get current local date
fn get_current_local_date() -> chrono::NaiveDate {
    Local::now().date_naive()
}

/// Get current local time
fn get_current_local_time() -> chrono::NaiveTime {
    Local::now().time()
}

// 3. Time Components

/// Get current year
fn get_current_year() -> i32 {
    Local::now().year()
}

/// Get current month (1-12)
fn get_current_month() -> u32 {
    Local::now().month()
}

/// Get current day (1-31)
fn get_current_day() -> u32 {
    Local::now().day()
}

/// Get current hour (0-23)
fn get_current_hour() -> u32 {
    Local::now().hour()
}

/// Get current minute (0-59)
fn get_current_minute() -> u32 {
    Local::now().minute()
}

/// Get current second (0-59)
fn get_current_second() -> u32 {
    Local::now().second()
}

// 4. Get All Components

/// Structure to hold time components
#[derive(Debug)]
struct TimeComponents {
    year: i32,
    month: u32,
    day: u32,
    hour: u32,
    minute: u32,
    second: u32,
    weekday: String,
    ordinal: u32,
}

/// Get all time components
fn get_time_components() -> TimeComponents {
    let now = Local::now();
    TimeComponents {
        year: now.year(),
        month: now.month(),
        day: now.day(),
        hour: now.hour(),
        minute: now.minute(),
        second: now.second(),
        weekday: now.format("%A").to_string(),
        ordinal: now.ordinal(),
    }
}

// 5. Week Information

/// Get current weekday (Monday=1, Sunday=7)
fn get_current_weekday() -> u32 {
    Local::now().weekday() as u32
}

/// Get weekday name
fn get_current_weekday_name() -> String {
    Local::now().format("%A").to_string()
}

/// Get weekday abbreviation
fn get_current_weekday_abbr() -> String {
    Local::now().format("%a").to_string()
}

/// Get ISO week number
fn get_current_iso_week() -> u32 {
    Local::now().iso_week().week()
}

/// Get ISO year
fn get_current_iso_year() -> i32 {
    Local::now().iso_week().year()
}

// 6. Day of Year

/// Get day of year (1-366)
fn get_current_day_of_year() -> u32 {
    Local::now().ordinal()
}

/// Get days remaining in year
fn get_days_remaining_in_year() -> i64 {
    let now = Local::now();
    let year = now.year();
    let start_of_next_year = chrono::NaiveDate::from_ymd_opt(year + 1, 1, 1).unwrap();
    (start_of_next_year - now.date_naive()).num_days()
}

/// Get percentage of year passed
fn get_year_progress() -> f64 {
    let now = Local::now();
    let start_of_year = chrono::NaiveDate::from_ymd_opt(now.year(), 1, 1).unwrap();
    let current_date = now.date_naive();
    let days_passed = (current_date - start_of_year).num_days() as f64;

    let is_leap_year = (now.year() % 4 == 0 && now.year() % 100 != 0) || (now.year() % 400 == 0);
    let days_in_year = if is_leap_year { 366.0 } else { 365.0 };

    (days_passed / days_in_year) * 100.0
}

// 7. Timezone Information

/// Get timezone name
fn get_timezone_name() -> String {
    Local::now().format("%Z").to_string()
}

/// Get timezone offset
fn get_timezone_offset() -> String {
    Local::now().format("%z").to_string()
}

// 8. Comparison Functions

/// Check if current time is before a given time
fn is_before(timestamp: i64) -> bool {
    get_current_timestamp() < timestamp
}

/// Check if current time is after a given time
fn is_after(timestamp: i64) -> bool {
    get_current_timestamp() > timestamp
}

/// Calculate age from birth timestamp
fn calculate_age(birth_timestamp: i64) -> i32 {
    let now = Utc::now();
    let birth = DateTime::from_timestamp(birth_timestamp, 0).unwrap();
    let age_years = now.signed_duration_since(birth).num_days() / 365;
    age_years as i32
}

// 9. Utility Functions

/// Check if current year is leap year
fn is_leap_year() -> bool {
    let year = Local::now().year();
    (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)
}

/// Get days in current month
fn get_days_in_current_month() -> u32 {
    let now = Local::now();
    let (next_year, next_month) = if now.month() == 12 {
        (now.year() + 1, 1)
    } else {
        (now.year(), now.month() + 1)
    };

    chrono::NaiveDate::from_ymd_opt(next_year, next_month, 1)
        .unwrap()
        .pred()
        .day()
}

/// Get quarter of year (1-4)
fn get_current_quarter() -> u32 {
    let month = Local::now().month();
    (month - 1) / 3 + 1
}

// 10. Time since

/// Get time elapsed since timestamp (human-readable)
fn time_elapsed_since(timestamp: i64) -> String {
    let now = Utc::now();
    let then = DateTime::from_timestamp(timestamp, 0).unwrap();
    let duration = now.signed_duration_since(then);

    if duration.num_days() > 0 {
        format!("{} days ago", duration.num_days())
    } else if duration.num_hours() > 0 {
        format!("{} hours ago", duration.num_hours())
    } else if duration.num_minutes() > 0 {
        format!("{} minutes ago", duration.num_minutes())
    } else {
        format!("{} seconds ago", duration.num_seconds())
    }
}

// Usage Examples
fn main() {
    println!("=== Web Rust Get Current Time Examples ===\n");

    // 1. UTC time
    println!("--- 1. Current UTC Time ---");
    println!("UTC DateTime: {}", get_current_utc());
    println!("Timestamp (seconds): {}", get_current_timestamp());
    println!("Timestamp (millis): {}", get_current_timestamp_millis());
    println!("Timestamp (micros): {}", get_current_timestamp_micros());

    // 2. Local time
    println!("\n--- 2. Current Local Time ---");
    println!("Local DateTime: {}", get_current_local());
    println!("Local Date: {}", get_current_local_date());
    println!("Local Time: {}", get_current_local_time());

    // 3. Time components
    println!("\n--- 3. Time Components ---");
    println!("Year: {}", get_current_year());
    println!("Month: {}", get_current_month());
    println!("Day: {}", get_current_day());
    println!("Hour: {}", get_current_hour());
    println!("Minute: {}", get_current_minute());
    println!("Second: {}", get_current_second());

    // 4. All components
    println!("\n--- 4. All Time Components ---");
    println!("{:?}", get_time_components());

    // 5. Week information
    println!("\n--- 5. Week Information ---");
    println!("Weekday (number): {}", get_current_weekday());
    println!("Weekday name: {}", get_current_weekday_name());
    println!("Weekday abbr: {}", get_current_weekday_abbr());
    println!("ISO week: {}", get_current_iso_week());
    println!("ISO year: {}", get_current_iso_year());

    // 6. Day of year
    println!("\n--- 6. Day of Year ---");
    println!("Day of year: {}", get_current_day_of_year());
    println!("Days remaining: {}", get_days_remaining_in_year());
    println!("Year progress: {:.2}%", get_year_progress());

    // 7. Timezone
    println!("\n--- 7. Timezone ---");
    println!("Timezone name: {}", get_timezone_name());
    println!("Timezone offset: {}", get_timezone_offset());

    // 8. Comparison
    println!("\n--- 8. Comparison ---");
    let past_timestamp = get_current_timestamp() - 3600;
    println!("Is before 1 hour ago: {}", is_before(past_timestamp));
    println!("Is after 1 hour ago: {}", is_after(past_timestamp));

    // 9. Utilities
    println!("\n--- 9. Utilities ---");
    println!("Is leap year: {}", is_leap_year());
    println!("Days in month: {}", get_days_in_current_month());
    println!("Quarter: {}", get_current_quarter());

    // 10. Time elapsed
    println!("\n--- 10. Time Elapsed ---");
    let past = get_current_timestamp() - 3661;
    println!("Since 1 hour 1 minute ago: {}", time_elapsed_since(past));

    let birth_timestamp = 946684800; // 2000-01-01
    println!("Age of someone born on 2000-01-01: {} years", calculate_age(birth_timestamp));

    println!("\n=== All Get Current Time Examples Completed ===");
}
CoderustIntermediate

Time Formatting

Format DateTime objects to strings with various formats and custom patterns

Difficulty

5/10

Estimated time

20 min

Tags

rust, web, datetime

Prerequisites

Intermediate Rust, chrono crate

rust
// Web Rust Time Formatting Examples
// Format DateTime to string representations
//
// Add to Cargo.toml:
// [dependencies]
// chrono = "0.4"

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

// 1. Predefined Formats

/// Format as ISO 8601 (UTC)
fn format_iso8601_utc(dt: DateTime<Utc>) -> String {
    dt.format("%Y-%m-%dT%H:%M:%SZ").to_string()
}

/// Format as ISO 8601 (local)
fn format_iso8601_local(dt: DateTime<Local>) -> String {
    dt.format("%Y-%m-%dT%H:%M:%S%z").to_string()
}

/// Format as RFC 2822
fn format_rfc2822(dt: DateTime<Local>) -> String {
    dt.format("%a, %d %b %Y %H:%M:%S %z").to_string()
}

/// Format as RFC 3339
fn format_rfc3339(dt: DateTime<Utc>) -> String {
    dt.format("%Y-%m-%dT%H:%M:%S%.9fZ").to_string()
}

// 2. Date Formats

/// Format as date only (YYYY-MM-DD)
fn format_date_only(dt: DateTime<Local>) -> String {
    dt.format("%Y-%m-%d").to_string()
}

/// Format as US date (MM/DD/YYYY)
fn format_date_us(dt: DateTime<Local>) -> String {
    dt.format("%m/%d/%Y").to_string()
}

/// Format as European date (DD/MM/YYYY)
fn format_date_eu(dt: DateTime<Local>) -> String {
    dt.format("%d/%m/%Y").to_string()
}

/// Format as long date (e.g., "Monday, January 1, 2024")
fn format_long_date(dt: DateTime<Local>) -> String {
    dt.format("%A, %B %d, %Y").to_string()
}

/// Format as short date (e.g., "Jan 1, 2024")
fn format_short_date(dt: DateTime<Local>) -> String {
    dt.format("%b %d, %Y").to_string()
}

// 3. Time Formats

/// Format as time only (24-hour)
fn format_time_24h(dt: DateTime<Local>) -> String {
    dt.format("%H:%M:%S").to_string()
}

/// Format as time only (12-hour)
fn format_time_12h(dt: DateTime<Local>) -> String {
    dt.format("%I:%M:%S %p").to_string()
}

/// Format as compact time (HH:MM)
fn format_time_compact(dt: DateTime<Local>) -> String {
    dt.format("%H:%M").to_string()
}

// 4. Combined Date-Time Formats

/// Format as common format (YYYY-MM-DD HH:MM:SS)
fn format_common(dt: DateTime<Local>) -> String {
    dt.format("%Y-%m-%d %H:%M:%S").to_string()
}

/// Format as human-readable
fn format_human_readable(dt: DateTime<Local>) -> String {
    dt.format("%A, %B %d, %Y at %I:%M %p").to_string()
}

/// Format as compact datetime
fn format_compact(dt: DateTime<Local>) -> String {
    dt.format("%Y%m%d_%H%M%S").to_string()
}

// 5. Custom Components

/// Format with weekday
fn format_with_weekday(dt: DateTime<Local>) -> String {
    dt.format("%a, %Y-%m-%d").to_string()
}

/// Format with week number
fn format_with_week(dt: DateTime<Local>) -> String {
    dt.format("%Y-W%V-%u").to_string()
}

/// Format with quarter
fn format_with_quarter(dt: DateTime<Local>) -> String {
    let quarter = (dt.month() - 1) / 3 + 1;
    format!("{}-Q{}", dt.year(), quarter)
}

/// Format with ordinal day
fn format_with_ordinal(dt: DateTime<Local>) -> String {
    let day = dt.day();
    let suffix = if day % 100 >= 11 && day % 100 <= 13 {
        "th"
    } else {
        match day % 10 {
            1 => "st",
            2 => "nd",
            3 => "rd",
            _ => "th",
        }
    };
    format!("{} {}{} {}", dt.format("%B"), day, suffix, dt.year())
}

// 6. Relative Formats

/// Format as "Today at HH:MM"
fn format_today_at(dt: DateTime<Local>) -> String {
    format!("Today at {}", dt.format("%I:%M %p"))
}

/// Format as "Month Day, Year at HH:MM AM/PM"
fn format_full_at(dt: DateTime<Local>) -> String {
    format!("{} at {}", dt.format("%B %d, %Y"), dt.format("%I:%M %p"))
}

// 7. Locale-Aware Formats (simplified)

/// Format for US locale
fn format_locale_us(dt: DateTime<Local>) -> String {
    dt.format("%B %d, %Y %I:%M:%S %p").to_string()
}

/// Format for European locale
fn format_locale_eu(dt: DateTime<Local>) -> String {
    dt.format("%d %B %Y %H:%M:%S").to_string()
}

/// Format for ISO locale
fn format_locale_iso(dt: DateTime<Local>) -> String {
    dt.format("%Y-%m-%d %H:%M").to_string()
}

// 8. Log/Debug Formats

/// Format for logging (compact and sortable)
fn format_log(dt: DateTime<Local>) -> String {
    dt.format("%Y%m%d-%H%M%S").to_string()
}

/// Format for filenames
fn format_filename(dt: DateTime<Local>) -> String {
    dt.format("%Y%m%d_%H%M%S").to_string()
}

/// Format for HTTP headers
fn format_http_date(dt: DateTime<Local>) -> String {
    dt.format("%a, %d %b %Y %H:%M:%S GMT").to_string()
}

// 9. Special Formats

/// Format as Unix timestamp string
fn format_timestamp_string(dt: DateTime<Utc>) -> String {
    dt.timestamp().to_string()
}

/// Format as duration from now
fn format_duration_from_now(dt: DateTime<Local>) -> String {
    let now = Local::now();
    let duration = now.signed_duration_since(dt);

    if duration.num_days() > 0 {
        format!("{} days ago", duration.num_days())
    } else if duration.num_hours() > 0 {
        format!("{} hours ago", duration.num_hours())
    } else if duration.num_minutes() > 0 {
        format!("{} minutes ago", duration.num_minutes())
    } else {
        format!("{} seconds ago", duration.num_seconds())
    }
}

/// Format as age
fn format_age(dt: DateTime<Local>) -> String {
    let now = Local::now();
    let duration = now.signed_duration_since(dt);
    let years = duration.num_days() / 365;
    format!("{} years", years)
}

// 10. Custom Format Function

/// Format with custom pattern
fn format_custom(dt: DateTime<Local>, pattern: &str) -> String {
    dt.format(pattern).to_string()
}

/// Format with multiple options
#[derive(Debug)]
struct FormatOptions {
    include_year: bool,
    include_month: bool,
    include_day: bool,
    include_time: bool,
    separator: String,
}

fn format_with_options(dt: DateTime<Local>, options: &FormatOptions) -> String {
    let mut parts = Vec::new();

    if options.include_year {
        parts.push(dt.format("%Y").to_string());
    }
    if options.include_month {
        parts.push(dt.format("%m").to_string());
    }
    if options.include_day {
        parts.push(dt.format("%d").to_string());
    }
    if options.include_time {
        parts.push(dt.format("%H:%M").to_string());
    }

    parts.join(&options.separator)
}

// Usage Examples
fn main() {
    println!("=== Web Rust Time Formatting Examples ===\n");

    let utc_now = Utc::now();
    let local_now = Local::now();

    // 1. Predefined formats
    println!("--- 1. Predefined Formats ---");
    println!("ISO 8601 (UTC): {}", format_iso8601_utc(utc_now));
    println!("ISO 8601 (local): {}", format_iso8601_local(local_now));
    println!("RFC 2822: {}", format_rfc2822(local_now));
    println!("RFC 3339: {}", format_rfc3339(utc_now));

    // 2. Date formats
    println!("\n--- 2. Date Formats ---");
    println!("Date only: {}", format_date_only(local_now));
    println!("US date: {}", format_date_us(local_now));
    println!("EU date: {}", format_date_eu(local_now));
    println!("Long date: {}", format_long_date(local_now));
    println!("Short date: {}", format_short_date(local_now));

    // 3. Time formats
    println!("\n--- 3. Time Formats ---");
    println!("Time (24h): {}", format_time_24h(local_now));
    println!("Time (12h): {}", format_time_12h(local_now));
    println!("Time (compact): {}", format_time_compact(local_now));

    // 4. Combined formats
    println!("\n--- 4. Combined Formats ---");
    println!("Common: {}", format_common(local_now));
    println!("Human readable: {}", format_human_readable(local_now));
    println!("Compact: {}", format_compact(local_now));

    // 5. Custom components
    println!("\n--- 5. Custom Components ---");
    println!("With weekday: {}", format_with_weekday(local_now));
    println!("With week: {}", format_with_week(local_now));
    println!("With quarter: {}", format_with_quarter(local_now));
    println!("With ordinal: {}", format_with_ordinal(local_now));

    // 6. Locale formats
    println!("\n--- 6. Locale Formats ---");
    println!("US locale: {}", format_locale_us(local_now));
    println!("EU locale: {}", format_locale_eu(local_now));
    println!("ISO locale: {}", format_locale_iso(local_now));

    // 7. Log/debug formats
    println!("\n--- 7. Log/Debug Formats ---");
    println!("Log format: {}", format_log(local_now));
    println!("Filename: {}", format_filename(local_now));
    println!("HTTP date: {}", format_http_date(local_now));

    // 8. Special formats
    println!("\n--- 8. Special Formats ---");
    println!("Timestamp: {}", format_timestamp_string(utc_now));
    println!("From now: {}", format_duration_from_now(local_now));

    // 9. Custom format
    println!("\n--- 9. Custom Format ---");
    println!("Custom (Day/Month/Year): {}", format_custom(local_now, "%d/%m/%Y"));

    // 10. Options-based format
    println!("\n--- 10. Format with Options ---");
    let options = FormatOptions {
        include_year: true,
        include_month: true,
        include_day: true,
        include_time: true,
        separator: "-".to_string(),
    };
    println!("With options: {}", format_with_options(local_now, &options));

    println!("\n=== All Time Formatting Examples Completed ===");
}
CoderustIntermediate

Time Parsing

Parse string representations into DateTime objects with various formats

Difficulty

6/10

Estimated time

25 min

Tags

rust, web, datetime

Prerequisites

Intermediate Rust, chrono crate

rust
// Web Rust Time Parsing Examples
// Parse strings into DateTime objects
//
// Add to Cargo.toml:
// [dependencies]
// chrono = "0.4"

use chrono::{DateTime, Local, NaiveDate, NaiveDateTime, NaiveTime, Utc, ParseError};
use std::str::FromStr;

// 1. Parse ISO 8601

/// Parse ISO 8601 string to DateTime UTC
fn parse_iso8601_utc(s: &str) -> Result<DateTime<Utc>, ParseError> {
    s.parse::<DateTime<Utc>>()
}

/// Parse ISO 8601 string to DateTime Local
fn parse_iso8601_local(s: &str) -> Result<DateTime<Local>, ParseError> {
    s.parse::<DateTime<Local>>()
}

// 2. Parse Custom Formats

/// Parse date string (YYYY-MM-DD)
fn parse_date_only(s: &str) -> Result<NaiveDate, ParseError> {
    NaiveDate::from_str(s)
}

/// Parse time string (HH:MM:SS)
fn parse_time_only(s: &str) -> Result<NaiveTime, ParseError> {
    NaiveTime::from_str(s)
}

/// Parse datetime string (YYYY-MM-DD HH:MM:SS)
fn parse_datetime_naive(s: &str) -> Result<NaiveDateTime, ParseError> {
    NaiveDateTime::from_str(s)
}

/// Parse with custom format string
fn parse_custom_format(s: &str, format: &str) -> Result<NaiveDateTime, ParseError> {
    NaiveDateTime::parse_from_str(s, format)
}

// 3. Parse Common Formats

/// Parse US date format (MM/DD/YYYY)
fn parse_us_date(s: &str) -> Result<NaiveDate, ParseError> {
    NaiveDate::parse_from_str(s, "%m/%d/%Y")
}

/// Parse European date format (DD/MM/YYYY)
fn parse_eu_date(s: &str) -> Result<NaiveDate, ParseError> {
    NaiveDate::parse_from_str(s, "%d/%m/%Y")
}

/// Parse compact date (YYYYMMDD)
fn parse_compact_date(s: &str) -> Result<NaiveDate, ParseError> {
    NaiveDate::parse_from_str(s, "%Y%m%d")
}

/// Parse RFC 2822 datetime
fn parse_rfc2822(s: &str) -> Result<DateTime<Utc>, ParseError> {
    DateTime::parse_from_rfc2822(s)
}

/// Parse RFC 3339 datetime
fn parse_rfc3339(s: &str) -> Result<DateTime<Utc>, ParseError> {
    DateTime::parse_from_rfc3339(s)
}

// 4. Parse with Flexible Formats

/// Try multiple formats until one succeeds
fn parse_flexible(s: &str, formats: &[&str]) -> Option<NaiveDateTime> {
    for format in formats {
        if let Ok(dt) = NaiveDateTime::parse_from_str(s, format) {
            return Some(dt);
        }
    }
    None
}

/// Parse date with multiple format attempts
fn parse_date_flexible(s: &str) -> Option<NaiveDate> {
    let formats = ["%Y-%m-%d", "%m/%d/%Y", "%d/%m/%Y", "%Y%m%d", "%b %d, %Y"];
    for format in formats {
        if let Ok(d) = NaiveDate::parse_from_str(s, format) {
            return Some(d);
        }
    }
    None
}

// 5. Parse Unix Timestamp

/// Parse Unix timestamp (seconds)
fn parse_timestamp_seconds(timestamp: i64) -> Result<DateTime<Utc>, ParseError> {
    DateTime::from_timestamp(timestamp, 0)
        .ok_or_else(|| ParseError::from_kind(chrono::format::ParseErrorKind::OutOfRange))
}

/// Parse Unix timestamp (milliseconds)
fn parse_timestamp_millis(timestamp: i64) -> Result<DateTime<Utc>, ParseError> {
    let seconds = timestamp / 1000;
    let nanos = ((timestamp % 1000) * 1_000_000) as u32;
    DateTime::from_timestamp(seconds, nanos)
        .ok_or_else(|| ParseError::from_kind(chrono::format::ParseErrorKind::OutOfRange))
}

// 6. Parse Relative Time

/// Parse "X days ago"
fn parse_days_ago(s: &str) -> Option<NaiveDateTime> {
    let re = regex::Regex::new(r"(d+)s+days?s+ago").ok()?;
    let caps = re.captures(s)?;
    let days: i64 = caps.get(1)?.as_str().parse().ok()?;
    Some(Local::now().naive_local() - chrono::Duration::days(days))
}

/// Parse "X hours ago"
fn parse_hours_ago(s: &str) -> Option<NaiveDateTime> {
    let re = regex::Regex::new(r"(d+)s+hours?s+ago").ok()?;
    let caps = re.captures(s)?;
    let hours: i64 = caps.get(1)?.as_str().parse().ok()?;
    Some(Local::now().naive_local() - chrono::Duration::hours(hours))
}

/// Parse "X minutes ago"
fn parse_minutes_ago(s: &str) -> Option<NaiveDateTime> {
    let re = regex::Regex::new(r"(d+)s+minutes?s+ago").ok()?;
    let caps = re.captures(s)?;
    let minutes: i64 = caps.get(1)?.as_str().parse().ok()?;
    Some(Local::now().naive_local() - chrono::Duration::minutes(minutes))
}

// 7. Extract Date Components

/// Extract year from string
fn extract_year(s: &str) -> Option<u32> {
    let re = regex::Regex::new(r"(d{4})").ok()?;
    let caps = re.captures(s)?;
    caps.get(1)?.as_str().parse().ok()
}

/// Extract month from string
fn extract_month(s: &str) -> Option<u32> {
    let re = regex::Regex::new(r"(0?[1-9]|1[0-2])").ok()?;
    let caps = re.captures(s)?;
    caps.get(1)?.as_str().parse().ok()
}

// 8. Parse with Validation

/// Parse date and validate it's not in the future
fn parse_date_not_future(s: &str, format: &str) -> Result<NaiveDate, ParseError> {
    let date = NaiveDate::parse_from_str(s, format)?;
    let today = Local::now().date_naive();

    if date > today {
        return Err(ParseError::from_kind(chrono::format::ParseErrorKind::OutOfRange));
    }

    Ok(date)
}

/// Parse date and validate it's within range
fn parse_date_in_range(
    s: &str,
    format: &str,
    min: NaiveDate,
    max: NaiveDate,
) -> Result<NaiveDate, ParseError> {
    let date = NaiveDate::parse_from_str(s, format)?;

    if date < min || date > max {
        return Err(ParseError::from_kind(chrono::format::ParseErrorKind::OutOfRange));
    }

    Ok(date)
}

// 9. Parse and Convert

/// Parse string and convert to timezone
fn parse_and_convert_timezone(
    s: &str,
    format: &str,
) -> Result<DateTime<Utc>, ParseError> {
    let naive_dt = NaiveDateTime::parse_from_str(s, format)?;
    Ok(Local.from_local_naive(&naive_dt).earliest().unwrap().with_timezone(&Utc))
}

// 10. Batch Parsing

/// Parse multiple dates with same format
fn parse_multiple_dates(dates: &[String], format: &str) -> Vec<Result<NaiveDate, ParseError>> {
    dates.iter()
        .map(|s| NaiveDate::parse_from_str(s, format))
        .collect()
}

/// Parse and sort dates
fn parse_and_sort_dates(dates: &[String], format: &str) -> Vec<NaiveDate> {
    dates.iter()
        .filter_map(|s| NaiveDate::parse_from_str(s, format).ok())
        .collect::<Vec<_>>()
        .into_iter()
        .collect::<Vec<_>>()
}

// Usage Examples
fn main() {
    println!("=== Web Rust Time Parsing Examples ===\n");

    // 1. Parse ISO 8601
    println!("--- 1. Parse ISO 8601 ---");
    match parse_iso8601_utc("2024-01-15T10:30:00Z") {
        Ok(dt) => println!("Parsed UTC: {}", dt),
        Err(e) => println!("Error: {}", e),
    }

    // 2. Parse custom formats
    println!("\n--- 2. Parse Custom Formats ---");
    match parse_date_only("2024-01-15") {
        Ok(date) => println!("Parsed date: {}", date),
        Err(e) => println!("Error: {}", e),
    }

    match parse_time_only("14:30:00") {
        Ok(time) => println!("Parsed time: {}", time),
        Err(e) => println!("Error: {}", e),
    }

    // 3. Parse common formats
    println!("\n--- 3. Parse Common Formats ---");
    match parse_us_date("01/15/2024") {
        Ok(date) => println!("US date: {}", date),
        Err(e) => println!("Error: {}", e),
    }

    match parse_eu_date("15/01/2024") {
        Ok(date) => println!("EU date: {}", date),
        Err(e) => println!("Error: {}", e),
    }

    // 4. Parse timestamps
    println!("\n--- 4. Parse Timestamps ---");
    match parse_timestamp_seconds(1705317600) {
        Ok(dt) => println!("Timestamp 1705317600: {}", dt),
        Err(e) => println!("Error: {}", e),
    }

    // 5. Parse with custom format
    println!("\n--- 5. Parse Custom Format ---");
    match parse_custom_format("January 15, 2024 10:30 AM", "%B %d, %Y %I:%M %p") {
        Ok(dt) => println!("Custom format: {}", dt),
        Err(e) => println!("Error: {}", e),
    }

    // 6. Flexible parsing
    println!("\n--- 6. Flexible Parsing ---");
    let date_str = "01/15/2024";
    match parse_date_flexible(date_str) {
        Some(date) => println!("Flexible parse '{}': {}", date_str, date),
        None => println!("Could not parse '{}'", date_str),
    }

    // 7. Parse RFC formats
    println!("\n--- 7. Parse RFC Formats ---");
    let rfc2822_str = "Mon, 15 Jan 2024 10:30:00 +0000";
    match parse_rfc2822(rfc2822_str) {
        Ok(dt) => println!("RFC 2822: {}", dt),
        Err(e) => println!("Error: {}", e),
    }

    // 8. Relative time parsing
    println!("\n--- 8. Parse Relative Time ---");
    match parse_days_ago("5 days ago") {
        Some(dt) => println!("5 days ago: {}", dt),
        None => println!("Could not parse"),
    }

    // 9. Extract components
    println!("\n--- 9. Extract Components ---");
    let text = "The event is on 2024-01-15";
    match extract_year(text) {
        Some(year) => println!("Extracted year: {}", year),
        None => println!("Could not extract year"),
    }

    // 10. Batch parsing
    println!("\n--- 10. Batch Parsing ---");
    let dates = vec![
        "2024-01-15".to_string(),
        "2024-02-20".to_string(),
        "2024-03-25".to_string(),
    ];
    let parsed = parse_multiple_dates(&dates, "%Y-%m-%d");
    println!("Parsed {} out of {} dates",
        parsed.iter().filter(|r| r.is_ok()).count(),
        dates.len()
    );

    println!("\n=== All Time Parsing Examples Completed ===");
}

Tools

Tools frequently paired with this sample

Related

Related sample collections

Related

Related workflows

Hub

Date and Time Normalization and Deadline Calculation

Turn ambiguous or mixed-format date inputs into validated, timezone-aware, business-ready timestamps, deadlines, and duration facts.

Hub

Authorized Webhook Capture and Endpoint Trust Checks

Capture and replay controlled webhook requests, inspect delivery evidence, and check the receiver HTTPS certificate without treating a valid certificate as proof of business trust.

Hub

Observability Debugging from Logs, Traces, Webhooks, and JSON Payloads

Parse logs, decode traces, inspect webhook/API evidence, explore JSON payloads, and extract recurring patterns before writing an incident-ready debugging note.

Hub

Text Encoding, Width, Date, and Currency Conversion Workflow

Prepare imported or copied text for reuse by recovering its encoding, choosing a character-width convention, standardizing inline dates or currency, and selecting a final text representation.

Home
Tools3212
Samples593
Visualizations471
Viewers103
Hubs239
Tags333
Images, Audio & Video657

Image, audio, and video processing, conversion, and optimization tools

Math, Date & Finance647

Calculators, numerics, date logic, statistics, and finance tools

Design & Color298

Color, layout, graphics, visual styling, and design helper tools

Text & Writing209

Writing, cleanup, formatting, extraction, and text analysis tools

Developer & Web193

Developer utilities, networking, web debugging, and automation helpers

Conversion & Encoding175

Format, file, archive, unit, and encoding conversion tools

Lead Generation Quiz Launch and Contact Handoff
Memorial Drafts: Family Review and Print Handoff
Private Habit Records: Backup, Restore and Sharing Review
Article to X and LinkedIn Drafts: Fact Review and Handoff
Markdown Interactive Deck Review and Offline Handoff

© 2026 Elysia Tools. All rights reserved.

DocsPricingAboutTerms of ServicePrivacy PolicyCookiesContact

Validation

Date & Time Validator

Validate date and time formats including ISO8601, custom formats, leap year, and month/day validation

Format Conversion

Date Formatter

Convert date strings to various formatted date formats

Text Processing

Date Extractor (日期提取器)

Extract dates from text in multiple formats including Chinese, ISO, and US formats with detailed analysis and summary

Utilities

Text Date Format Unifier

Find and unify date formats within text content

Utilities

Date Format Unifier

Convert various date formats to a unified format

Date & Time

Time Duration Formatter

Format time duration into various human-readable formats

Date & Time

Time Adder/Subtractor

Add or subtract time from a date

Utilities

Date Adder

Add or subtract time periods from a date (years, months, days, hours, minutes, seconds)

Swift

macOS Date & Time Swift Samples

macOS Swift date and time examples including getting current time, formatting, and parsing dates

Go

Web Date & Time Go Samples

Web Go date and time examples including getting current time, formatting, parsing, and timezone operations

Python

Web Date & Time Python Samples

Web Python date and time examples including getting current time, formatting, parsing, and timezone operations

TypeScript

Web Date Time TypeScript Samples

Web TypeScript date and time examples including getting current time, formatting, parsing, and manipulation

C++

Windows Date and Time - C++ Samples

Comprehensive C++ date and time examples for Windows platform including time acquisition, formatting, and parsing operations

Rust

Web File Operations Rust Samples

Web Rust file operations examples including text file read/write, file copy/move, directory traversal, and file validation