impl NaiveDateTime

const fn new(date: NaiveDate, time: NaiveTime) -> NaiveDateTime

Makes a new NaiveDateTime from date and time components. Equivalent to date.and_time(time) and many other helper constructors on NaiveDate.

Example

use chrono::{NaiveDate, NaiveDateTime, NaiveTime};

let d = NaiveDate::from_ymd_opt(2015, 6, 3).unwrap();
let t = NaiveTime::from_hms_milli_opt(12, 34, 56, 789).unwrap();

let dt = NaiveDateTime::new(d, t);
assert_eq!(dt.date(), d);
assert_eq!(dt.time(), t);

const fn from_timestamp(secs: i64, nsecs: u32) -> NaiveDateTime

Makes a new NaiveDateTime corresponding to a UTC date and time, from the number of non-leap seconds since the midnight UTC on January 1, 1970 (aka "UNIX timestamp") and the number of nanoseconds since the last whole non-leap second.

For a non-naive version of this function see TimeZone::timestamp.

The nanosecond part can exceed 1,000,000,000 in order to represent a leap second, but only when secs % 60 == 59. (The true "UNIX timestamp" cannot represent a leap second unambiguously.)

Panics

Panics if the number of seconds would be out of range for a NaiveDateTime (more than ca. 262,000 years away from common era), and panics on an invalid nanosecond (2 seconds or more).

const fn from_timestamp_millis(millis: i64) -> Option<NaiveDateTime>

Creates a new [NaiveDateTime] from milliseconds since the UNIX epoch.

The UNIX epoch starts on midnight, January 1, 1970, UTC.

Errors

Returns None if the number of milliseconds would be out of range for a NaiveDateTime (more than ca. 262,000 years away from common era)

const fn from_timestamp_micros(micros: i64) -> Option<NaiveDateTime>

Creates a new [NaiveDateTime] from microseconds since the UNIX epoch.

The UNIX epoch starts on midnight, January 1, 1970, UTC.

Errors

Returns None if the number of microseconds would be out of range for a NaiveDateTime (more than ca. 262,000 years away from common era)

const fn from_timestamp_nanos(nanos: i64) -> Option<NaiveDateTime>

Creates a new [NaiveDateTime] from nanoseconds since the UNIX epoch.

The UNIX epoch starts on midnight, January 1, 1970, UTC.

Errors

Returns None if the number of nanoseconds would be out of range for a NaiveDateTime (more than ca. 262,000 years away from common era)

const fn from_timestamp_opt(secs: i64, nsecs: u32) -> Option<NaiveDateTime>

Makes a new NaiveDateTime corresponding to a UTC date and time, from the number of non-leap seconds since the midnight UTC on January 1, 1970 (aka "UNIX timestamp") and the number of nanoseconds since the last whole non-leap second.

The nanosecond part can exceed 1,000,000,000 in order to represent a leap second, but only when secs % 60 == 59. (The true "UNIX timestamp" cannot represent a leap second unambiguously.)

Errors

Returns None if the number of seconds would be out of range for a NaiveDateTime (more than ca. 262,000 years away from common era), and panics on an invalid nanosecond (2 seconds or more).

fn parse_from_str(s: &str, fmt: &str) -> ParseResult<NaiveDateTime>

Parses a string with the specified format string and returns a new NaiveDateTime. See the format::strftime module on the supported escape sequences.

Example

use chrono::{NaiveDate, NaiveDateTime};

let parse_from_str = NaiveDateTime::parse_from_str;

assert_eq!(
    parse_from_str("2015-09-05 23:56:04", "%Y-%m-%d %H:%M:%S"),
    Ok(NaiveDate::from_ymd_opt(2015, 9, 5).unwrap().and_hms_opt(23, 56, 4).unwrap())
);
assert_eq!(
    parse_from_str("5sep2015pm012345.6789", "%d%b%Y%p%I%M%S%.f"),
    Ok(NaiveDate::from_ymd_opt(2015, 9, 5)
        .unwrap()
        .and_hms_micro_opt(13, 23, 45, 678_900)
        .unwrap())
);

Offset is ignored for the purpose of parsing.

# use chrono::{NaiveDateTime, NaiveDate};
# let parse_from_str = NaiveDateTime::parse_from_str;
assert_eq!(
    parse_from_str("2014-5-17T12:34:56+09:30", "%Y-%m-%dT%H:%M:%S%z"),
    Ok(NaiveDate::from_ymd_opt(2014, 5, 17).unwrap().and_hms_opt(12, 34, 56).unwrap())
);

Leap seconds are correctly handled by treating any time of the form hh:mm:60 as a leap second. (This equally applies to the formatting, so the round trip is possible.)

# use chrono::{NaiveDateTime, NaiveDate};
# let parse_from_str = NaiveDateTime::parse_from_str;
assert_eq!(
    parse_from_str("2015-07-01 08:59:60.123", "%Y-%m-%d %H:%M:%S%.f"),
    Ok(NaiveDate::from_ymd_opt(2015, 7, 1)
        .unwrap()
        .and_hms_milli_opt(8, 59, 59, 1_123)
        .unwrap())
);

Missing seconds are assumed to be zero, but out-of-bound times or insufficient fields are errors otherwise.

# use chrono::{NaiveDateTime, NaiveDate};
# let parse_from_str = NaiveDateTime::parse_from_str;
assert_eq!(
    parse_from_str("94/9/4 7:15", "%y/%m/%d %H:%M"),
    Ok(NaiveDate::from_ymd_opt(1994, 9, 4).unwrap().and_hms_opt(7, 15, 0).unwrap())
);

assert!(parse_from_str("04m33s", "%Mm%Ss").is_err());
assert!(parse_from_str("94/9/4 12", "%y/%m/%d %H").is_err());
assert!(parse_from_str("94/9/4 17:60", "%y/%m/%d %H:%M").is_err());
assert!(parse_from_str("94/9/4 24:00:00", "%y/%m/%d %H:%M:%S").is_err());

All parsed fields should be consistent to each other, otherwise it's an error.

# use chrono::NaiveDateTime;
# let parse_from_str = NaiveDateTime::parse_from_str;
let fmt = "%Y-%m-%d %H:%M:%S = UNIX timestamp %s";
assert!(parse_from_str("2001-09-09 01:46:39 = UNIX timestamp 999999999", fmt).is_ok());
assert!(parse_from_str("1970-01-01 00:00:00 = UNIX timestamp 1", fmt).is_err());

Years before 1 BCE or after 9999 CE, require an initial sign

 # use chrono::NaiveDateTime;
 # let parse_from_str = NaiveDateTime::parse_from_str;
 let fmt = "%Y-%m-%d %H:%M:%S";
 assert!(parse_from_str("10000-09-09 01:46:39", fmt).is_err());
 assert!(parse_from_str("+10000-09-09 01:46:39", fmt).is_ok());

fn parse_and_remainder<'a>(s: &'a str, fmt: &str) -> ParseResult<(NaiveDateTime, &'a str)>

Parses a string with the specified format string and returns a new NaiveDateTime, and a slice with the remaining portion of the string. See the format::strftime module on the supported escape sequences.

Similar to parse_from_str.

Example

# use chrono::{NaiveDate, NaiveDateTime};
let (datetime, remainder) = NaiveDateTime::parse_and_remainder(
    "2015-02-18 23:16:09 trailing text",
    "%Y-%m-%d %H:%M:%S",
)
.unwrap();
assert_eq!(
    datetime,
    NaiveDate::from_ymd_opt(2015, 2, 18).unwrap().and_hms_opt(23, 16, 9).unwrap()
);
assert_eq!(remainder, " trailing text");

const fn date(self: &Self) -> NaiveDate

Retrieves a date component.

Example

use chrono::NaiveDate;

let dt = NaiveDate::from_ymd_opt(2016, 7, 8).unwrap().and_hms_opt(9, 10, 11).unwrap();
assert_eq!(dt.date(), NaiveDate::from_ymd_opt(2016, 7, 8).unwrap());

const fn time(self: &Self) -> NaiveTime

Retrieves a time component.

Example

use chrono::{NaiveDate, NaiveTime};

let dt = NaiveDate::from_ymd_opt(2016, 7, 8).unwrap().and_hms_opt(9, 10, 11).unwrap();
assert_eq!(dt.time(), NaiveTime::from_hms_opt(9, 10, 11).unwrap());

const fn timestamp(self: &Self) -> i64

Returns the number of non-leap seconds since the midnight on January 1, 1970.

Note that this does not account for the timezone! The true "UNIX timestamp" would count seconds since the midnight UTC on the epoch.

const fn timestamp_millis(self: &Self) -> i64

Returns the number of non-leap milliseconds since midnight on January 1, 1970.

Note that this does not account for the timezone! The true "UNIX timestamp" would count seconds since the midnight UTC on the epoch.

const fn timestamp_micros(self: &Self) -> i64

Returns the number of non-leap microseconds since midnight on January 1, 1970.

Note that this does not account for the timezone! The true "UNIX timestamp" would count seconds since the midnight UTC on the epoch.

const fn timestamp_nanos(self: &Self) -> i64

Returns the number of non-leap nanoseconds since midnight on January 1, 1970.

Note that this does not account for the timezone! The true "UNIX timestamp" would count seconds since the midnight UTC on the epoch.

Panics

An i64 with nanosecond precision can span a range of ~584 years. This function panics on an out of range NaiveDateTime.

The dates that can be represented as nanoseconds are between 1677-09-21T00:12:43.145224192 and 2262-04-11T23:47:16.854775807.

const fn timestamp_nanos_opt(self: &Self) -> Option<i64>

Returns the number of non-leap nanoseconds since midnight on January 1, 1970.

Note that this does not account for the timezone! The true "UNIX timestamp" would count seconds since the midnight UTC on the epoch.

Errors

An i64 with nanosecond precision can span a range of ~584 years. This function returns None on an out of range NaiveDateTime.

The dates that can be represented as nanoseconds are between 1677-09-21T00:12:43.145224192 and 2262-04-11T23:47:16.854775807.

const fn timestamp_subsec_millis(self: &Self) -> u32

Returns the number of milliseconds since the last whole non-leap second.

The return value ranges from 0 to 999, or for leap seconds, to 1,999.

const fn timestamp_subsec_micros(self: &Self) -> u32

Returns the number of microseconds since the last whole non-leap second.

The return value ranges from 0 to 999,999, or for leap seconds, to 1,999,999.

const fn timestamp_subsec_nanos(self: &Self) -> u32

Returns the number of nanoseconds since the last whole non-leap second.

The return value ranges from 0 to 999,999,999, or for leap seconds, to 1,999,999,999.

const fn checked_add_signed(self: Self, rhs: TimeDelta) -> Option<NaiveDateTime>

Adds given TimeDelta to the current date and time.

As a part of Chrono's leap second handling, the addition assumes that there is no leap second ever, except when the NaiveDateTime itself represents a leap second in which case the assumption becomes that there is exactly a single leap second ever.

Errors

Returns None if the resulting date would be out of range.

Example

use chrono::{NaiveDate, TimeDelta};

let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();

let d = from_ymd(2016, 7, 8);
let hms = |h, m, s| d.and_hms_opt(h, m, s).unwrap();
assert_eq!(hms(3, 5, 7).checked_add_signed(TimeDelta::zero()), Some(hms(3, 5, 7)));
assert_eq!(
    hms(3, 5, 7).checked_add_signed(TimeDelta::try_seconds(1).unwrap()),
    Some(hms(3, 5, 8))
);
assert_eq!(
    hms(3, 5, 7).checked_add_signed(TimeDelta::try_seconds(-1).unwrap()),
    Some(hms(3, 5, 6))
);
assert_eq!(
    hms(3, 5, 7).checked_add_signed(TimeDelta::try_seconds(3600 + 60).unwrap()),
    Some(hms(4, 6, 7))
);
assert_eq!(
    hms(3, 5, 7).checked_add_signed(TimeDelta::try_seconds(86_400).unwrap()),
    Some(from_ymd(2016, 7, 9).and_hms_opt(3, 5, 7).unwrap())
);

let hmsm = |h, m, s, milli| d.and_hms_milli_opt(h, m, s, milli).unwrap();
assert_eq!(
    hmsm(3, 5, 7, 980).checked_add_signed(TimeDelta::try_milliseconds(450).unwrap()),
    Some(hmsm(3, 5, 8, 430))
);

Overflow returns None.

# use chrono::{TimeDelta, NaiveDate};
# let hms = |h, m, s| NaiveDate::from_ymd_opt(2016, 7, 8).unwrap().and_hms_opt(h, m, s).unwrap();
assert_eq!(hms(3, 5, 7).checked_add_signed(TimeDelta::try_days(1_000_000_000).unwrap()), None);

Leap seconds are handled, but the addition assumes that it is the only leap second happened.

# use chrono::{TimeDelta, NaiveDate};
# let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();
# let hmsm = |h, m, s, milli| from_ymd(2016, 7, 8).and_hms_milli_opt(h, m, s, milli).unwrap();
let leap = hmsm(3, 5, 59, 1_300);
assert_eq!(leap.checked_add_signed(TimeDelta::zero()),
           Some(hmsm(3, 5, 59, 1_300)));
assert_eq!(leap.checked_add_signed(TimeDelta::try_milliseconds(-500).unwrap()),
           Some(hmsm(3, 5, 59, 800)));
assert_eq!(leap.checked_add_signed(TimeDelta::try_milliseconds(500).unwrap()),
           Some(hmsm(3, 5, 59, 1_800)));
assert_eq!(leap.checked_add_signed(TimeDelta::try_milliseconds(800).unwrap()),
           Some(hmsm(3, 6, 0, 100)));
assert_eq!(leap.checked_add_signed(TimeDelta::try_seconds(10).unwrap()),
           Some(hmsm(3, 6, 9, 300)));
assert_eq!(leap.checked_add_signed(TimeDelta::try_seconds(-10).unwrap()),
           Some(hmsm(3, 5, 50, 300)));
assert_eq!(leap.checked_add_signed(TimeDelta::try_days(1).unwrap()),
           Some(from_ymd(2016, 7, 9).and_hms_milli_opt(3, 5, 59, 300).unwrap()));

const fn checked_add_months(self: Self, rhs: Months) -> Option<NaiveDateTime>

Adds given Months to the current date and time.

Uses the last day of the month if the day does not exist in the resulting month.

Errors

Returns None if the resulting date would be out of range.

Example

use chrono::{Months, NaiveDate};

assert_eq!(
    NaiveDate::from_ymd_opt(2014, 1, 1)
        .unwrap()
        .and_hms_opt(1, 0, 0)
        .unwrap()
        .checked_add_months(Months::new(1)),
    Some(NaiveDate::from_ymd_opt(2014, 2, 1).unwrap().and_hms_opt(1, 0, 0).unwrap())
);

assert_eq!(
    NaiveDate::from_ymd_opt(2014, 1, 1)
        .unwrap()
        .and_hms_opt(1, 0, 0)
        .unwrap()
        .checked_add_months(Months::new(core::i32::MAX as u32 + 1)),
    None
);

const fn checked_add_offset(self: Self, rhs: FixedOffset) -> Option<NaiveDateTime>

Adds given FixedOffset to the current datetime. Returns None if the result would be outside the valid range for NaiveDateTime.

This method is similar to checked_add_signed, but preserves leap seconds.

const fn checked_sub_offset(self: Self, rhs: FixedOffset) -> Option<NaiveDateTime>

Subtracts given FixedOffset from the current datetime. Returns None if the result would be outside the valid range for NaiveDateTime.

This method is similar to checked_sub_signed, but preserves leap seconds.

const fn checked_sub_signed(self: Self, rhs: TimeDelta) -> Option<NaiveDateTime>

Subtracts given TimeDelta from the current date and time.

As a part of Chrono's leap second handling, the subtraction assumes that there is no leap second ever, except when the NaiveDateTime itself represents a leap second in which case the assumption becomes that there is exactly a single leap second ever.

Errors

Returns None if the resulting date would be out of range.

Example

use chrono::{NaiveDate, TimeDelta};

let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();

let d = from_ymd(2016, 7, 8);
let hms = |h, m, s| d.and_hms_opt(h, m, s).unwrap();
assert_eq!(hms(3, 5, 7).checked_sub_signed(TimeDelta::zero()), Some(hms(3, 5, 7)));
assert_eq!(
    hms(3, 5, 7).checked_sub_signed(TimeDelta::try_seconds(1).unwrap()),
    Some(hms(3, 5, 6))
);
assert_eq!(
    hms(3, 5, 7).checked_sub_signed(TimeDelta::try_seconds(-1).unwrap()),
    Some(hms(3, 5, 8))
);
assert_eq!(
    hms(3, 5, 7).checked_sub_signed(TimeDelta::try_seconds(3600 + 60).unwrap()),
    Some(hms(2, 4, 7))
);
assert_eq!(
    hms(3, 5, 7).checked_sub_signed(TimeDelta::try_seconds(86_400).unwrap()),
    Some(from_ymd(2016, 7, 7).and_hms_opt(3, 5, 7).unwrap())
);

let hmsm = |h, m, s, milli| d.and_hms_milli_opt(h, m, s, milli).unwrap();
assert_eq!(
    hmsm(3, 5, 7, 450).checked_sub_signed(TimeDelta::try_milliseconds(670).unwrap()),
    Some(hmsm(3, 5, 6, 780))
);

Overflow returns None.

# use chrono::{TimeDelta, NaiveDate};
# let hms = |h, m, s| NaiveDate::from_ymd_opt(2016, 7, 8).unwrap().and_hms_opt(h, m, s).unwrap();
assert_eq!(hms(3, 5, 7).checked_sub_signed(TimeDelta::try_days(1_000_000_000).unwrap()), None);

Leap seconds are handled, but the subtraction assumes that it is the only leap second happened.

# use chrono::{TimeDelta, NaiveDate};
# let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();
# let hmsm = |h, m, s, milli| from_ymd(2016, 7, 8).and_hms_milli_opt(h, m, s, milli).unwrap();
let leap = hmsm(3, 5, 59, 1_300);
assert_eq!(leap.checked_sub_signed(TimeDelta::zero()),
           Some(hmsm(3, 5, 59, 1_300)));
assert_eq!(leap.checked_sub_signed(TimeDelta::try_milliseconds(200).unwrap()),
           Some(hmsm(3, 5, 59, 1_100)));
assert_eq!(leap.checked_sub_signed(TimeDelta::try_milliseconds(500).unwrap()),
           Some(hmsm(3, 5, 59, 800)));
assert_eq!(leap.checked_sub_signed(TimeDelta::try_seconds(60).unwrap()),
           Some(hmsm(3, 5, 0, 300)));
assert_eq!(leap.checked_sub_signed(TimeDelta::try_days(1).unwrap()),
           Some(from_ymd(2016, 7, 7).and_hms_milli_opt(3, 6, 0, 300).unwrap()));

const fn checked_sub_months(self: Self, rhs: Months) -> Option<NaiveDateTime>

Subtracts given Months from the current date and time.

Uses the last day of the month if the day does not exist in the resulting month.

Errors

Returns None if the resulting date would be out of range.

Example

use chrono::{Months, NaiveDate};

assert_eq!(
    NaiveDate::from_ymd_opt(2014, 1, 1)
        .unwrap()
        .and_hms_opt(1, 0, 0)
        .unwrap()
        .checked_sub_months(Months::new(1)),
    Some(NaiveDate::from_ymd_opt(2013, 12, 1).unwrap().and_hms_opt(1, 0, 0).unwrap())
);

assert_eq!(
    NaiveDate::from_ymd_opt(2014, 1, 1)
        .unwrap()
        .and_hms_opt(1, 0, 0)
        .unwrap()
        .checked_sub_months(Months::new(core::i32::MAX as u32 + 1)),
    None
);

const fn checked_add_days(self: Self, days: Days) -> Option<Self>

Add a duration in Days to the date part of the NaiveDateTime

Returns None if the resulting date would be out of range.

const fn checked_sub_days(self: Self, days: Days) -> Option<Self>

Subtract a duration in Days from the date part of the NaiveDateTime

Returns None if the resulting date would be out of range.

const fn signed_duration_since(self: Self, rhs: NaiveDateTime) -> TimeDelta

Subtracts another NaiveDateTime from the current date and time. This does not overflow or underflow at all.

As a part of Chrono's leap second handling, the subtraction assumes that there is no leap second ever, except when any of the NaiveDateTimes themselves represents a leap second in which case the assumption becomes that there are exactly one (or two) leap second(s) ever.

Example

use chrono::{NaiveDate, TimeDelta};

let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();

let d = from_ymd(2016, 7, 8);
assert_eq!(
    d.and_hms_opt(3, 5, 7).unwrap().signed_duration_since(d.and_hms_opt(2, 4, 6).unwrap()),
    TimeDelta::try_seconds(3600 + 60 + 1).unwrap()
);

// July 8 is 190th day in the year 2016
let d0 = from_ymd(2016, 1, 1);
assert_eq!(
    d.and_hms_milli_opt(0, 7, 6, 500)
        .unwrap()
        .signed_duration_since(d0.and_hms_opt(0, 0, 0).unwrap()),
    TimeDelta::try_seconds(189 * 86_400 + 7 * 60 + 6).unwrap()
        + TimeDelta::try_milliseconds(500).unwrap()
);

Leap seconds are handled, but the subtraction assumes that there were no other leap seconds happened.

# use chrono::{TimeDelta, NaiveDate};
# let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();
let leap = from_ymd(2015, 6, 30).and_hms_milli_opt(23, 59, 59, 1_500).unwrap();
assert_eq!(
    leap.signed_duration_since(from_ymd(2015, 6, 30).and_hms_opt(23, 0, 0).unwrap()),
    TimeDelta::try_seconds(3600).unwrap() + TimeDelta::try_milliseconds(500).unwrap()
);
assert_eq!(
    from_ymd(2015, 7, 1).and_hms_opt(1, 0, 0).unwrap().signed_duration_since(leap),
    TimeDelta::try_seconds(3600).unwrap() - TimeDelta::try_milliseconds(500).unwrap()
);

fn format_with_items<'a, I, B>(self: &Self, items: I) -> DelayedFormat<I>
where
    I: Iterator<Item = B> + Clone,
    B: Borrow<Item<'a>>

Formats the combined date and time with the specified formatting items. Otherwise it is the same as the ordinary format method.

The Iterator of items should be Cloneable, since the resulting DelayedFormat value may be formatted multiple times.

Example

use chrono::format::strftime::StrftimeItems;
use chrono::NaiveDate;

let fmt = StrftimeItems::new("%Y-%m-%d %H:%M:%S");
let dt = NaiveDate::from_ymd_opt(2015, 9, 5).unwrap().and_hms_opt(23, 56, 4).unwrap();
assert_eq!(dt.format_with_items(fmt.clone()).to_string(), "2015-09-05 23:56:04");
assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2015-09-05 23:56:04");

The resulting DelayedFormat can be formatted directly via the Display trait.

# use chrono::NaiveDate;
# use chrono::format::strftime::StrftimeItems;
# let fmt = StrftimeItems::new("%Y-%m-%d %H:%M:%S").clone();
# let dt = NaiveDate::from_ymd_opt(2015, 9, 5).unwrap().and_hms_opt(23, 56, 4).unwrap();
assert_eq!(format!("{}", dt.format_with_items(fmt)), "2015-09-05 23:56:04");

fn format<'a>(self: &Self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>

Formats the combined date and time with the specified format string. See the format::strftime module on the supported escape sequences.

This returns a DelayedFormat, which gets converted to a string only when actual formatting happens. You may use the to_string method to get a String, or just feed it into print! and other formatting macros. (In this way it avoids the redundant memory allocation.)

A wrong format string does not issue an error immediately. Rather, converting or formatting the DelayedFormat fails. You are recommended to immediately use DelayedFormat for this reason.

Example

use chrono::NaiveDate;

let dt = NaiveDate::from_ymd_opt(2015, 9, 5).unwrap().and_hms_opt(23, 56, 4).unwrap();
assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2015-09-05 23:56:04");
assert_eq!(dt.format("around %l %p on %b %-d").to_string(), "around 11 PM on Sep 5");

The resulting DelayedFormat can be formatted directly via the Display trait.

# use chrono::NaiveDate;
# let dt = NaiveDate::from_ymd_opt(2015, 9, 5).unwrap().and_hms_opt(23, 56, 4).unwrap();
assert_eq!(format!("{}", dt.format("%Y-%m-%d %H:%M:%S")), "2015-09-05 23:56:04");
assert_eq!(format!("{}", dt.format("around %l %p on %b %-d")), "around 11 PM on Sep 5");

fn and_local_timezone<Tz: TimeZone>(self: &Self, tz: Tz) -> MappedLocalTime<DateTime<Tz>>

Converts the NaiveDateTime into a timezone-aware DateTime<Tz> with the provided time zone.

Example

use chrono::{FixedOffset, NaiveDate};
let hour = 3600;
let tz = FixedOffset::east_opt(5 * hour).unwrap();
let dt = NaiveDate::from_ymd_opt(2015, 9, 5)
    .unwrap()
    .and_hms_opt(23, 56, 4)
    .unwrap()
    .and_local_timezone(tz)
    .unwrap();
assert_eq!(dt.timezone(), tz);

const fn and_utc(self: &Self) -> DateTime<Utc>

Converts the NaiveDateTime into the timezone-aware DateTime<Utc>.

Example

use chrono::{NaiveDate, Utc};
let dt =
    NaiveDate::from_ymd_opt(2023, 1, 30).unwrap().and_hms_opt(19, 32, 33).unwrap().and_utc();
assert_eq!(dt.timezone(), Utc);

impl Add for NaiveDateTime

fn add(self: Self, days: Days) -> <Self as >::Output

impl Add for NaiveDateTime

fn add(self: Self, rhs: TimeDelta) -> NaiveDateTime

impl Add for NaiveDateTime

fn add(self: Self, rhs: Months) -> <Self as >::Output

impl Add for NaiveDateTime

fn add(self: Self, rhs: Duration) -> NaiveDateTime

impl Add for NaiveDateTime

fn add(self: Self, rhs: FixedOffset) -> NaiveDateTime

impl AddAssign for NaiveDateTime

fn add_assign(self: &mut Self, rhs: Duration)

impl AddAssign for NaiveDateTime

fn add_assign(self: &mut Self, rhs: TimeDelta)

impl Clone for NaiveDateTime

fn clone(self: &Self) -> NaiveDateTime

impl Copy for NaiveDateTime

impl Datelike for NaiveDateTime

fn year(self: &Self) -> i32

Returns the year number in the calendar date.

See also the NaiveDate::year method.

Example

use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.year(), 2015);

fn month(self: &Self) -> u32

Returns the month number starting from 1.

The return value ranges from 1 to 12.

See also the NaiveDate::month method.

Example

use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.month(), 9);

fn month0(self: &Self) -> u32

Returns the month number starting from 0.

The return value ranges from 0 to 11.

See also the NaiveDate::month0 method.

Example

use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.month0(), 8);

fn day(self: &Self) -> u32

Returns the day of month starting from 1.

The return value ranges from 1 to 31. (The last day of month differs by months.)

See also the NaiveDate::day method.

Example

use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.day(), 25);

fn day0(self: &Self) -> u32

Returns the day of month starting from 0.

The return value ranges from 0 to 30. (The last day of month differs by months.)

See also the NaiveDate::day0 method.

Example

use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.day0(), 24);

fn ordinal(self: &Self) -> u32

Returns the day of year starting from 1.

The return value ranges from 1 to 366. (The last day of year differs by years.)

See also the NaiveDate::ordinal method.

Example

use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.ordinal(), 268);

fn ordinal0(self: &Self) -> u32

Returns the day of year starting from 0.

The return value ranges from 0 to 365. (The last day of year differs by years.)

See also the NaiveDate::ordinal0 method.

Example

use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.ordinal0(), 267);

fn weekday(self: &Self) -> Weekday

Returns the day of week.

See also the NaiveDate::weekday method.

Example

use chrono::{Datelike, NaiveDate, NaiveDateTime, Weekday};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.weekday(), Weekday::Fri);

fn iso_week(self: &Self) -> IsoWeek

fn with_year(self: &Self, year: i32) -> Option<NaiveDateTime>

Makes a new NaiveDateTime with the year number changed, while keeping the same month and day.

See also the NaiveDate::with_year method.

Errors

Returns None if:

• The resulting date does not exist (February 29 in a non-leap year).
• The year is out of range for a NaiveDate.

Example

use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
    dt.with_year(2016),
    Some(NaiveDate::from_ymd_opt(2016, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(
    dt.with_year(-308),
    Some(NaiveDate::from_ymd_opt(-308, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap())
);

fn with_month(self: &Self, month: u32) -> Option<NaiveDateTime>

Makes a new NaiveDateTime with the month number (starting from 1) changed.

Don't combine multiple Datelike::with_* methods. The intermediate value may not exist.

See also the NaiveDate::with_month method.

Errors

Returns None if:

• The resulting date does not exist (for example month(4) when day of the month is 31).
• The value for month is invalid.

Example

use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 30).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
    dt.with_month(10),
    Some(NaiveDate::from_ymd_opt(2015, 10, 30).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(dt.with_month(13), None); // No month 13
assert_eq!(dt.with_month(2), None); // No February 30

fn with_month0(self: &Self, month0: u32) -> Option<NaiveDateTime>

Makes a new NaiveDateTime with the month number (starting from 0) changed.

See also the NaiveDate::with_month0 method.

Errors

Returns None if:

• The resulting date does not exist (for example month0(3) when day of the month is 31).
• The value for month0 is invalid.

Example

use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 30).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
    dt.with_month0(9),
    Some(NaiveDate::from_ymd_opt(2015, 10, 30).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(dt.with_month0(12), None); // No month 13
assert_eq!(dt.with_month0(1), None); // No February 30

fn with_day(self: &Self, day: u32) -> Option<NaiveDateTime>

Makes a new NaiveDateTime with the day of month (starting from 1) changed.

See also the NaiveDate::with_day method.

Errors

Returns None if:

• The resulting date does not exist (for example day(31) in April).
• The value for day is invalid.

Example

use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
    dt.with_day(30),
    Some(NaiveDate::from_ymd_opt(2015, 9, 30).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(dt.with_day(31), None); // no September 31

fn with_day0(self: &Self, day0: u32) -> Option<NaiveDateTime>

Makes a new NaiveDateTime with the day of month (starting from 0) changed.

See also the NaiveDate::with_day0 method.

Errors

Returns None if:

• The resulting date does not exist (for example day(30) in April).
• The value for day0 is invalid.

Example

use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
    dt.with_day0(29),
    Some(NaiveDate::from_ymd_opt(2015, 9, 30).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(dt.with_day0(30), None); // no September 31

fn with_ordinal(self: &Self, ordinal: u32) -> Option<NaiveDateTime>

Makes a new NaiveDateTime with the day of year (starting from 1) changed.

See also the NaiveDate::with_ordinal method.

Errors

Returns None if:

• The resulting date does not exist (with_ordinal(366) in a non-leap year).
• The value for ordinal is invalid.

Example

use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
    dt.with_ordinal(60),
    Some(NaiveDate::from_ymd_opt(2015, 3, 1).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(dt.with_ordinal(366), None); // 2015 had only 365 days

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2016, 9, 8).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
    dt.with_ordinal(60),
    Some(NaiveDate::from_ymd_opt(2016, 2, 29).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(
    dt.with_ordinal(366),
    Some(NaiveDate::from_ymd_opt(2016, 12, 31).unwrap().and_hms_opt(12, 34, 56).unwrap())
);

fn with_ordinal0(self: &Self, ordinal0: u32) -> Option<NaiveDateTime>

Makes a new NaiveDateTime with the day of year (starting from 0) changed.

See also the NaiveDate::with_ordinal0 method.

Errors

Returns None if:

• The resulting date does not exist (with_ordinal0(365) in a non-leap year).
• The value for ordinal0 is invalid.

Example

use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
    dt.with_ordinal0(59),
    Some(NaiveDate::from_ymd_opt(2015, 3, 1).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(dt.with_ordinal0(365), None); // 2015 had only 365 days

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2016, 9, 8).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
    dt.with_ordinal0(59),
    Some(NaiveDate::from_ymd_opt(2016, 2, 29).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(
    dt.with_ordinal0(365),
    Some(NaiveDate::from_ymd_opt(2016, 12, 31).unwrap().and_hms_opt(12, 34, 56).unwrap())
);

impl Debug for NaiveDateTime

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

impl Default for NaiveDateTime

fn default() -> Self

impl Display for NaiveDateTime

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

impl DurationRound for NaiveDateTime

fn duration_round(self: Self, duration: TimeDelta) -> Result<Self, <Self as >::Err>

fn duration_trunc(self: Self, duration: TimeDelta) -> Result<Self, <Self as >::Err>

impl Eq for NaiveDateTime

impl Freeze for NaiveDateTime

impl From for NaiveDateTime

fn from(date: NaiveDate) -> Self

Converts a NaiveDate to a NaiveDateTime of the same date but at midnight.

Example

use chrono::{NaiveDate, NaiveDateTime};

let nd = NaiveDate::from_ymd_opt(2016, 5, 28).unwrap();
let ndt = NaiveDate::from_ymd_opt(2016, 5, 28).unwrap().and_hms_opt(0, 0, 0).unwrap();
assert_eq!(ndt, NaiveDateTime::from(nd));

impl FromStr for NaiveDateTime

fn from_str(s: &str) -> ParseResult<NaiveDateTime>

impl Hash for NaiveDateTime

fn hash<__H: $crate::hash::Hasher>(self: &Self, state: &mut __H)

impl Ord for NaiveDateTime

fn cmp(self: &Self, other: &NaiveDateTime) -> Ordering

impl PartialEq for NaiveDateTime

fn eq(self: &Self, other: &NaiveDateTime) -> bool

impl PartialOrd for NaiveDateTime

fn partial_cmp(self: &Self, other: &NaiveDateTime) -> Option<Ordering>

impl RefUnwindSafe for NaiveDateTime

impl Send for NaiveDateTime

impl StructuralPartialEq for NaiveDateTime

impl Sub for NaiveDateTime

fn sub(self: Self, rhs: Duration) -> NaiveDateTime

impl Sub for NaiveDateTime

fn sub(self: Self, rhs: FixedOffset) -> NaiveDateTime

impl Sub for NaiveDateTime

fn sub(self: Self, rhs: TimeDelta) -> NaiveDateTime

impl Sub for NaiveDateTime

fn sub(self: Self, rhs: NaiveDateTime) -> TimeDelta

impl Sub for NaiveDateTime

fn sub(self: Self, days: Days) -> <Self as >::Output

impl Sub for NaiveDateTime

fn sub(self: Self, rhs: Months) -> <Self as >::Output

impl SubAssign for NaiveDateTime

fn sub_assign(self: &mut Self, rhs: Duration)

impl SubAssign for NaiveDateTime

fn sub_assign(self: &mut Self, rhs: TimeDelta)

impl Sync for NaiveDateTime

impl Timelike for NaiveDateTime

fn hour(self: &Self) -> u32

Returns the hour number from 0 to 23.

See also the NaiveTime::hour method.

Example

use chrono::{NaiveDate, NaiveDateTime, Timelike};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(dt.hour(), 12);

fn minute(self: &Self) -> u32

Returns the minute number from 0 to 59.

See also the NaiveTime::minute method.

Example

use chrono::{NaiveDate, NaiveDateTime, Timelike};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(dt.minute(), 34);

fn second(self: &Self) -> u32

Returns the second number from 0 to 59.

See also the NaiveTime::second method.

Example

use chrono::{NaiveDate, NaiveDateTime, Timelike};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(dt.second(), 56);

fn nanosecond(self: &Self) -> u32

Returns the number of nanoseconds since the whole non-leap second. The range from 1,000,000,000 to 1,999,999,999 represents the leap second.

See also the [NaiveTime#method.nanosecond] method.

Example

use chrono::{NaiveDate, NaiveDateTime, Timelike};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(dt.nanosecond(), 789_000_000);

fn with_hour(self: &Self, hour: u32) -> Option<NaiveDateTime>

Makes a new NaiveDateTime with the hour number changed.

See also the NaiveTime::with_hour method.

Errors

Returns None if the value for hour is invalid.

Example

use chrono::{NaiveDate, NaiveDateTime, Timelike};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(
    dt.with_hour(7),
    Some(
        NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(7, 34, 56, 789).unwrap()
    )
);
assert_eq!(dt.with_hour(24), None);

fn with_minute(self: &Self, min: u32) -> Option<NaiveDateTime>

Makes a new NaiveDateTime with the minute number changed.

See also the NaiveTime::with_minute method.

Errors

Returns None if the value for minute is invalid.

Example

use chrono::{NaiveDate, NaiveDateTime, Timelike};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(
    dt.with_minute(45),
    Some(
        NaiveDate::from_ymd_opt(2015, 9, 8)
            .unwrap()
            .and_hms_milli_opt(12, 45, 56, 789)
            .unwrap()
    )
);
assert_eq!(dt.with_minute(60), None);

fn with_second(self: &Self, sec: u32) -> Option<NaiveDateTime>

Makes a new NaiveDateTime with the second number changed.

As with the second method, the input range is restricted to 0 through 59.

See also the NaiveTime::with_second method.

Errors

Returns None if the value for second is invalid.

Example

use chrono::{NaiveDate, NaiveDateTime, Timelike};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(
    dt.with_second(17),
    Some(
        NaiveDate::from_ymd_opt(2015, 9, 8)
            .unwrap()
            .and_hms_milli_opt(12, 34, 17, 789)
            .unwrap()
    )
);
assert_eq!(dt.with_second(60), None);

fn with_nanosecond(self: &Self, nano: u32) -> Option<NaiveDateTime>

Makes a new NaiveDateTime with nanoseconds since the whole non-leap second changed.

Returns None when the resulting NaiveDateTime would be invalid. As with the NaiveDateTime::nanosecond method, the input range can exceed 1,000,000,000 for leap seconds.

See also the NaiveTime::with_nanosecond method.

Errors

Returns None if nanosecond >= 2,000,000,000.

Example

use chrono::{NaiveDate, NaiveDateTime, Timelike};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 59, 789).unwrap();
assert_eq!(
    dt.with_nanosecond(333_333_333),
    Some(
        NaiveDate::from_ymd_opt(2015, 9, 8)
            .unwrap()
            .and_hms_nano_opt(12, 34, 59, 333_333_333)
            .unwrap()
    )
);
assert_eq!(
    dt.with_nanosecond(1_333_333_333), // leap second
    Some(
        NaiveDate::from_ymd_opt(2015, 9, 8)
            .unwrap()
            .and_hms_nano_opt(12, 34, 59, 1_333_333_333)
            .unwrap()
    )
);
assert_eq!(dt.with_nanosecond(2_000_000_000), None);

impl Unpin for NaiveDateTime

impl UnsafeUnpin for NaiveDateTime

impl UnwindSafe for NaiveDateTime

impl<T> Any for NaiveDateTime

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for NaiveDateTime

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for NaiveDateTime

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> CloneToUninit for NaiveDateTime

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> From for NaiveDateTime

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> SubsecRound for NaiveDateTime

fn round_subsecs(self: Self, digits: u16) -> T

fn trunc_subsecs(self: Self, digits: u16) -> T

impl<T> ToOwned for NaiveDateTime

fn to_owned(self: &Self) -> T

fn clone_into(self: &Self, target: &mut T)

impl<T> ToString for NaiveDateTime

fn to_string(self: &Self) -> String

impl<T, U> Into for NaiveDateTime

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for NaiveDateTime

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for NaiveDateTime

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>