Parsing and Displaying

Recipe	Crates	Categories
Examine the date and time
Convert date to UNIX timestamp and vice versa
Display formatted date and time
Parse string into DateTime struct

Examine the date and time

Gets the current UTC chrono::DateTime⮳ and its hour/minute/second via chrono::Timelike⮳ and its year/month/day/weekday via chrono::Datelike⮳

use chrono::Datelike;
use chrono::Timelike;
use chrono::Utc;

fn main() {
    let now = Utc::now();

    let (is_pm, hour) = now.hour12();
    println!(
        "The current UTC time is {:02}:{:02}:{:02} {}",
        hour,
        now.minute(),
        now.second(),
        if is_pm { "PM" } else { "AM" }
    );
    println!(
        "And there have been {} seconds since midnight",
        now.num_seconds_from_midnight()
    );

    let (is_common_era, year) = now.year_ce();
    println!(
        "The current UTC date is {}-{:02}-{:02} {:?} ({})",
        year,
        now.month(),
        now.day(),
        now.weekday(),
        if is_common_era { "CE" } else { "BCE" }
    );
    println!(
        "And the Common Era began {} days ago",
        now.num_days_from_ce()
    );
}

Convert date to UNIX timestamp and vice versa

Converts a date given by chrono::naive::NaiveDate::from_ymd⮳ and chrono::naive::NaiveTime::from_hms⮳ to UNIX time stamp⮳ using chrono::naive::NaiveDateTime::timestamp⮳

Then it calculates what was the date after one billion seconds since January 1, 1970 0:00:00 UTC, using chrono::naive::NaiveDateTime::from_timestamp⮳.

use chrono::DateTime;
use chrono::NaiveDate;
use chrono::NaiveDateTime;

fn main() {
    let date_time: NaiveDateTime = NaiveDate::from_ymd_opt(2017, 11, 12)
        .unwrap()
        .and_hms_opt(17, 33, 44)
        .unwrap();
    println!(
        "Number of seconds between 1970-01-01 00:00:00 and {} is
    {}.",
        date_time,
        date_time.and_utc().timestamp()
    );

    let date_time_after_a_billion_seconds =
        DateTime::from_timestamp(1_000_000_000, 0).unwrap();
    println!(
        "Date after a billion seconds since 1970-01-01 00:00:00 was
    {}.",
        date_time_after_a_billion_seconds
    );
}

Display formatted date and time

Gets and displays the current time in UTC using chrono::offset::Utc::now⮳.

Formats the current time in the well-known RFC 2822 format⮳ using chrono::DateTime::to_rfc2822⮳ and RFC 3339⮳ using chrono::DateTime::to_rfc3339⮳ and in a custom format using chrono::DateTime::format⮳.

use chrono::DateTime;
use chrono::Utc;

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

    println!("UTC now is: {}", now);
    println!("UTC now in RFC 2822 is: {}", now.to_rfc2822());
    println!("UTC now in RFC 3339 is: {}", now.to_rfc3339());
    println!(
        "UTC now in a custom format is: {}",
        now.format("%a %b %e %T %Y")
    );
}

Parse string into DateTime struct

Parses a chrono::DateTime⮳ struct from strings representing the well-known RFC 2822 format⮳ and RFC 3339 format⮳, and a custom format, using chrono::DateTime::parse_from_rfc2822⮳ chrono::DateTime::parse_from_rfc2822⮳ and chrono::DateTime::parse_from_str⮳ respectively.

Escape sequences that are available for the chrono::DateTime::parse_from_str⮳ can be found at chrono::format::strftime⮳. Note that the chrono::DateTime::parse_from_str⮳ requires that such a DateTime struct must be creatable that it uniquely identifies a date and a time. For parsing dates and times without timezones use chrono::naive::NaiveDate⮳ chrono::naive::NaiveTime⮳ and chrono::naive::NaiveDateTime⮳.

use chrono::DateTime;
use chrono::NaiveDate;
use chrono::NaiveDateTime;
use chrono::NaiveTime;
use chrono::format::ParseError;

fn main() -> Result<(), ParseError> {
    let rfc2822 =
        DateTime::parse_from_rfc2822("Tue, 1 Jul 2003 10:52:37 +0200")?;
    println!("{}", rfc2822);

    let rfc3339 = DateTime::parse_from_rfc3339("1996-12-19T16:39:57-08:00")?;
    println!("{}", rfc3339);

    let custom = DateTime::parse_from_str(
        "5.8.1994 8:00 am +0000",
        "%d.%m.%Y %H:%M %P %z",
    )?;
    println!("{}", custom);

    let time_only = NaiveTime::parse_from_str("23:56:04", "%H:%M:%S")?;
    println!("{}", time_only);

    let date_only = NaiveDate::parse_from_str("2015-09-05", "%Y-%m-%d")?;
    println!("{}", date_only);

    let no_timezone = NaiveDateTime::parse_from_str(
        "2015-09-05 23:56:04",
        "%Y-%m-%d %H:%M:%S",
    )?;
    println!("{}", no_timezone);

    Ok(())
}