Struct chrono::naive::date::NaiveDate

pub struct NaiveDate {
    yof: NonZeroI32,
}

ISO 8601 calendar date without timezone. Allows for every proleptic Gregorian date from Jan 1, 262145 BCE to Dec 31, 262143 CE. Also supports the conversion from ISO 8601 ordinal and week date.

Calendar Date

The ISO 8601 calendar date follows the proleptic Gregorian calendar. It is like a normal civil calendar but note some slight differences:

• Dates before the Gregorian calendar’s inception in 1582 are defined via the extrapolation. Be careful, as historical dates are often noted in the Julian calendar and others and the transition to Gregorian may differ across countries (as late as early 20C).

  (Some example: Both Shakespeare from Britain and Cervantes from Spain seemingly died on the same calendar date—April 23, 1616—but in the different calendar. Britain used the Julian calendar at that time, so Shakespeare’s death is later.)

• ISO 8601 calendars has the year 0, which is 1 BCE (a year before 1 CE). If you need a typical BCE/BC and CE/AD notation for year numbers, use the Datelike::year_ce method.

Week Date

The ISO 8601 week date is a triple of year number, week number and day of the week with the following rules:

• A week consists of Monday through Sunday, and is always numbered within some year. The week number ranges from 1 to 52 or 53 depending on the year.

• The week 1 of given year is defined as the first week containing January 4 of that year, or equivalently, the first week containing four or more days in that year.

• The year number in the week date may not correspond to the actual Gregorian year. For example, January 3, 2016 (Sunday) was on the last (53rd) week of 2015.

Chrono’s date types default to the ISO 8601 calendar date, but Datelike::iso_week and Datelike::weekday methods can be used to get the corresponding week date.

Ordinal Date

The ISO 8601 ordinal date is a pair of year number and day of the year (“ordinal”). The ordinal number ranges from 1 to 365 or 366 depending on the year. The year number is the same as that of the calendar date.

This is currently the internal format of Chrono’s date types.

Fields

yof: NonZeroI32

Implementations

impl NaiveDate

pub(crate) fn weeks_from(&self, day: Weekday) -> i32

const fn from_ordinal_and_flags( year: i32, ordinal: u32, flags: YearFlags, ) -> Option<NaiveDate>

Makes a new NaiveDate from year, ordinal and flags. Does not check whether the flags are correct for the provided year.

const fn from_mdf(year: i32, mdf: Mdf) -> Option<NaiveDate>

Makes a new NaiveDate from year and packed month-day-flags. Does not check whether the flags are correct for the provided year.

pub const fn from_ymd(year: i32, month: u32, day: u32) -> NaiveDate

👎Deprecated since 0.4.23: use from_ymd_opt() instead

Makes a new NaiveDate from the calendar date (year, month and day).

Panics

Panics if the specified calendar day does not exist, on invalid values for month or day, or if year is out of range for NaiveDate.

pub const fn from_ymd_opt(year: i32, month: u32, day: u32) -> Option<NaiveDate>

Makes a new NaiveDate from the calendar date (year, month and day).

Errors

Returns None if:

• The specified calendar day does not exist (for example 2023-04-31).
• The value for month or day is invalid.
• year is out of range for NaiveDate.

Example

use chrono::NaiveDate;

let from_ymd_opt = NaiveDate::from_ymd_opt;

assert!(from_ymd_opt(2015, 3, 14).is_some());
assert!(from_ymd_opt(2015, 0, 14).is_none());
assert!(from_ymd_opt(2015, 2, 29).is_none());
assert!(from_ymd_opt(-4, 2, 29).is_some()); // 5 BCE is a leap year
assert!(from_ymd_opt(400000, 1, 1).is_none());
assert!(from_ymd_opt(-400000, 1, 1).is_none());

pub const fn from_yo(year: i32, ordinal: u32) -> NaiveDate

👎Deprecated since 0.4.23: use from_yo_opt() instead

Makes a new NaiveDate from the ordinal date (year and day of the year).

Panics

Panics if the specified ordinal day does not exist, on invalid values for ordinal, or if year is out of range for NaiveDate.

pub const fn from_yo_opt(year: i32, ordinal: u32) -> Option<NaiveDate>

Makes a new NaiveDate from the ordinal date (year and day of the year).

Errors

Returns None if:

• The specified ordinal day does not exist (for example 2023-366).
• The value for ordinal is invalid (for example: 0, 400).
• year is out of range for NaiveDate.

Example

use chrono::NaiveDate;

let from_yo_opt = NaiveDate::from_yo_opt;

assert!(from_yo_opt(2015, 100).is_some());
assert!(from_yo_opt(2015, 0).is_none());
assert!(from_yo_opt(2015, 365).is_some());
assert!(from_yo_opt(2015, 366).is_none());
assert!(from_yo_opt(-4, 366).is_some()); // 5 BCE is a leap year
assert!(from_yo_opt(400000, 1).is_none());
assert!(from_yo_opt(-400000, 1).is_none());

pub const fn from_isoywd(year: i32, week: u32, weekday: Weekday) -> NaiveDate

👎Deprecated since 0.4.23: use from_isoywd_opt() instead

Makes a new NaiveDate from the ISO week date (year, week number and day of the week). The resulting NaiveDate may have a different year from the input year.

Panics

Panics if the specified week does not exist in that year, on invalid values for week, or if the resulting date is out of range for NaiveDate.

pub const fn from_isoywd_opt( year: i32, week: u32, weekday: Weekday, ) -> Option<NaiveDate>

Makes a new NaiveDate from the ISO week date (year, week number and day of the week). The resulting NaiveDate may have a different year from the input year.

Errors

Returns None if:

• The specified week does not exist in that year (for example 2023 week 53).
• The value for week is invalid (for example: 0, 60).
• If the resulting date is out of range for NaiveDate.

Example

use chrono::{NaiveDate, Weekday};

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

assert_eq!(from_isoywd_opt(2015, 0, Weekday::Sun), None);
assert_eq!(from_isoywd_opt(2015, 10, Weekday::Sun), Some(from_ymd(2015, 3, 8)));
assert_eq!(from_isoywd_opt(2015, 30, Weekday::Mon), Some(from_ymd(2015, 7, 20)));
assert_eq!(from_isoywd_opt(2015, 60, Weekday::Mon), None);

assert_eq!(from_isoywd_opt(400000, 10, Weekday::Fri), None);
assert_eq!(from_isoywd_opt(-400000, 10, Weekday::Sat), None);

The year number of ISO week date may differ from that of the calendar date.

//           Mo Tu We Th Fr Sa Su
// 2014-W52  22 23 24 25 26 27 28    has 4+ days of new year,
// 2015-W01  29 30 31  1  2  3  4 <- so this is the first week
assert_eq!(from_isoywd_opt(2014, 52, Weekday::Sun), Some(from_ymd(2014, 12, 28)));
assert_eq!(from_isoywd_opt(2014, 53, Weekday::Mon), None);
assert_eq!(from_isoywd_opt(2015, 1, Weekday::Mon), Some(from_ymd(2014, 12, 29)));

// 2015-W52  21 22 23 24 25 26 27    has 4+ days of old year,
// 2015-W53  28 29 30 31  1  2  3 <- so this is the last week
// 2016-W01   4  5  6  7  8  9 10
assert_eq!(from_isoywd_opt(2015, 52, Weekday::Sun), Some(from_ymd(2015, 12, 27)));
assert_eq!(from_isoywd_opt(2015, 53, Weekday::Sun), Some(from_ymd(2016, 1, 3)));
assert_eq!(from_isoywd_opt(2015, 54, Weekday::Mon), None);
assert_eq!(from_isoywd_opt(2016, 1, Weekday::Mon), Some(from_ymd(2016, 1, 4)));

pub const fn from_num_days_from_ce(days: i32) -> NaiveDate

👎Deprecated since 0.4.23: use from_num_days_from_ce_opt() instead

Makes a new NaiveDate from a day’s number in the proleptic Gregorian calendar, with January 1, 1 being day 1.

Panics

Panics if the date is out of range.

pub const fn from_num_days_from_ce_opt(days: i32) -> Option<NaiveDate>

Makes a new NaiveDate from a day’s number in the proleptic Gregorian calendar, with January 1, 1 being day 1.

Errors

Returns None if the date is out of range.

Example

use chrono::NaiveDate;

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

assert_eq!(from_ndays_opt(730_000), Some(from_ymd(1999, 9, 3)));
assert_eq!(from_ndays_opt(1), Some(from_ymd(1, 1, 1)));
assert_eq!(from_ndays_opt(0), Some(from_ymd(0, 12, 31)));
assert_eq!(from_ndays_opt(-1), Some(from_ymd(0, 12, 30)));
assert_eq!(from_ndays_opt(100_000_000), None);
assert_eq!(from_ndays_opt(-100_000_000), None);

pub const fn from_weekday_of_month( year: i32, month: u32, weekday: Weekday, n: u8, ) -> NaiveDate

👎Deprecated since 0.4.23: use from_weekday_of_month_opt() instead

Makes a new NaiveDate by counting the number of occurrences of a particular day-of-week since the beginning of the given month. For instance, if you want the 2nd Friday of March 2017, you would use NaiveDate::from_weekday_of_month(2017, 3, Weekday::Fri, 2).

n is 1-indexed.

Panics

Panics if the specified day does not exist in that month, on invalid values for month or n, or if year is out of range for NaiveDate.

pub const fn from_weekday_of_month_opt( year: i32, month: u32, weekday: Weekday, n: u8, ) -> Option<NaiveDate>

Makes a new NaiveDate by counting the number of occurrences of a particular day-of-week since the beginning of the given month. For instance, if you want the 2nd Friday of March 2017, you would use NaiveDate::from_weekday_of_month(2017, 3, Weekday::Fri, 2).

n is 1-indexed.

Errors

Returns None if:

• The specified day does not exist in that month (for example the 5th Monday of Apr. 2023).
• The value for month or n is invalid.
• year is out of range for NaiveDate.

Example

use chrono::{NaiveDate, Weekday};
assert_eq!(
    NaiveDate::from_weekday_of_month_opt(2017, 3, Weekday::Fri, 2),
    NaiveDate::from_ymd_opt(2017, 3, 10)
)

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

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

Example

use chrono::NaiveDate;

let parse_from_str = NaiveDate::parse_from_str;

assert_eq!(
    parse_from_str("2015-09-05", "%Y-%m-%d"),
    Ok(NaiveDate::from_ymd_opt(2015, 9, 5).unwrap())
);
assert_eq!(
    parse_from_str("5sep2015", "%d%b%Y"),
    Ok(NaiveDate::from_ymd_opt(2015, 9, 5).unwrap())
);

Time and offset is ignored for the purpose of parsing.

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())
);

Out-of-bound dates or insufficient fields are errors.

assert!(parse_from_str("2015/9", "%Y/%m").is_err());
assert!(parse_from_str("2015/9/31", "%Y/%m/%d").is_err());

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

assert!(parse_from_str("Sat, 09 Aug 2013", "%a, %d %b %Y").is_err());

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

Parses a string from a user-specified format into a new NaiveDate value, 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

let (date, remainder) =
    NaiveDate::parse_and_remainder("2015-02-18 trailing text", "%Y-%m-%d").unwrap();
assert_eq!(date, NaiveDate::from_ymd_opt(2015, 2, 18).unwrap());
assert_eq!(remainder, " trailing text");

pub const fn checked_add_months(self, months: Months) -> Option<Self>

Add a duration in Months to the date

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

assert_eq!(
    NaiveDate::from_ymd_opt(2022, 2, 20).unwrap().checked_add_months(Months::new(6)),
    Some(NaiveDate::from_ymd_opt(2022, 8, 20).unwrap())
);
assert_eq!(
    NaiveDate::from_ymd_opt(2022, 7, 31).unwrap().checked_add_months(Months::new(2)),
    Some(NaiveDate::from_ymd_opt(2022, 9, 30).unwrap())
);

pub const fn checked_sub_months(self, months: Months) -> Option<Self>

Subtract a duration in Months from the date

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

assert_eq!(
    NaiveDate::from_ymd_opt(2022, 2, 20).unwrap().checked_sub_months(Months::new(6)),
    Some(NaiveDate::from_ymd_opt(2021, 8, 20).unwrap())
);

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

const fn diff_months(self, months: i32) -> Option<Self>

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

Add a duration in Days to the date

Errors

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

Example

assert_eq!(
    NaiveDate::from_ymd_opt(2022, 2, 20).unwrap().checked_add_days(Days::new(9)),
    Some(NaiveDate::from_ymd_opt(2022, 3, 1).unwrap())
);
assert_eq!(
    NaiveDate::from_ymd_opt(2022, 7, 31).unwrap().checked_add_days(Days::new(2)),
    Some(NaiveDate::from_ymd_opt(2022, 8, 2).unwrap())
);
assert_eq!(
    NaiveDate::from_ymd_opt(2022, 7, 31).unwrap().checked_add_days(Days::new(1000000000000)),
    None
);

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

Subtract a duration in Days from the date

Errors

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

Example

assert_eq!(
    NaiveDate::from_ymd_opt(2022, 2, 20).unwrap().checked_sub_days(Days::new(6)),
    Some(NaiveDate::from_ymd_opt(2022, 2, 14).unwrap())
);
assert_eq!(
    NaiveDate::from_ymd_opt(2022, 2, 20).unwrap().checked_sub_days(Days::new(1000000000000)),
    None
);

pub(crate) const fn add_days(self, days: i32) -> Option<Self>

Add a duration of i32 days to the date.

pub const fn and_time(&self, time: NaiveTime) -> NaiveDateTime

Makes a new NaiveDateTime from the current date and given NaiveTime.

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 = d.and_time(t);
assert_eq!(dt.date(), d);
assert_eq!(dt.time(), t);

pub const fn and_hms(&self, hour: u32, min: u32, sec: u32) -> NaiveDateTime

👎Deprecated since 0.4.23: use and_hms_opt() instead

Makes a new NaiveDateTime from the current date, hour, minute and second.

No leap second is allowed here; use NaiveDate::and_hms_* methods with a subsecond parameter instead.

Panics

Panics on invalid hour, minute and/or second.

pub const fn and_hms_opt( &self, hour: u32, min: u32, sec: u32, ) -> Option<NaiveDateTime>

Makes a new NaiveDateTime from the current date, hour, minute and second.

No leap second is allowed here; use NaiveDate::and_hms_*_opt methods with a subsecond parameter instead.

Errors

Returns None on invalid hour, minute and/or second.

Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd_opt(2015, 6, 3).unwrap();
assert!(d.and_hms_opt(12, 34, 56).is_some());
assert!(d.and_hms_opt(12, 34, 60).is_none()); // use `and_hms_milli_opt` instead
assert!(d.and_hms_opt(12, 60, 56).is_none());
assert!(d.and_hms_opt(24, 34, 56).is_none());

pub const fn and_hms_milli( &self, hour: u32, min: u32, sec: u32, milli: u32, ) -> NaiveDateTime

👎Deprecated since 0.4.23: use and_hms_milli_opt() instead

Makes a new NaiveDateTime from the current date, hour, minute, second and millisecond.

The millisecond part is allowed to exceed 1,000,000,000 in order to represent a leap second, but only when sec == 59.

Panics

Panics on invalid hour, minute, second and/or millisecond.

pub const fn and_hms_milli_opt( &self, hour: u32, min: u32, sec: u32, milli: u32, ) -> Option<NaiveDateTime>

Makes a new NaiveDateTime from the current date, hour, minute, second and millisecond.

The millisecond part is allowed to exceed 1,000,000,000 in order to represent a leap second, but only when sec == 59.

Errors

Returns None on invalid hour, minute, second and/or millisecond.

Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd_opt(2015, 6, 3).unwrap();
assert!(d.and_hms_milli_opt(12, 34, 56, 789).is_some());
assert!(d.and_hms_milli_opt(12, 34, 59, 1_789).is_some()); // leap second
assert!(d.and_hms_milli_opt(12, 34, 59, 2_789).is_none());
assert!(d.and_hms_milli_opt(12, 34, 60, 789).is_none());
assert!(d.and_hms_milli_opt(12, 60, 56, 789).is_none());
assert!(d.and_hms_milli_opt(24, 34, 56, 789).is_none());

pub const fn and_hms_micro( &self, hour: u32, min: u32, sec: u32, micro: u32, ) -> NaiveDateTime

👎Deprecated since 0.4.23: use and_hms_micro_opt() instead

Makes a new NaiveDateTime from the current date, hour, minute, second and microsecond.

The microsecond part is allowed to exceed 1,000,000,000 in order to represent a leap second, but only when sec == 59.

Panics

Panics on invalid hour, minute, second and/or microsecond.

Example

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

let d = NaiveDate::from_ymd_opt(2015, 6, 3).unwrap();

let dt: NaiveDateTime = d.and_hms_micro_opt(12, 34, 56, 789_012).unwrap();
assert_eq!(dt.year(), 2015);
assert_eq!(dt.weekday(), Weekday::Wed);
assert_eq!(dt.second(), 56);
assert_eq!(dt.nanosecond(), 789_012_000);

pub const fn and_hms_micro_opt( &self, hour: u32, min: u32, sec: u32, micro: u32, ) -> Option<NaiveDateTime>

Makes a new NaiveDateTime from the current date, hour, minute, second and microsecond.

The microsecond part is allowed to exceed 1,000,000 in order to represent a leap second, but only when sec == 59.

Errors

Returns None on invalid hour, minute, second and/or microsecond.

Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd_opt(2015, 6, 3).unwrap();
assert!(d.and_hms_micro_opt(12, 34, 56, 789_012).is_some());
assert!(d.and_hms_micro_opt(12, 34, 59, 1_789_012).is_some()); // leap second
assert!(d.and_hms_micro_opt(12, 34, 59, 2_789_012).is_none());
assert!(d.and_hms_micro_opt(12, 34, 60, 789_012).is_none());
assert!(d.and_hms_micro_opt(12, 60, 56, 789_012).is_none());
assert!(d.and_hms_micro_opt(24, 34, 56, 789_012).is_none());

pub const fn and_hms_nano( &self, hour: u32, min: u32, sec: u32, nano: u32, ) -> NaiveDateTime

👎Deprecated since 0.4.23: use and_hms_nano_opt() instead

Makes a new NaiveDateTime from the current date, hour, minute, second and nanosecond.

The nanosecond part is allowed to exceed 1,000,000,000 in order to represent a leap second, but only when sec == 59.

Panics

Panics on invalid hour, minute, second and/or nanosecond.

pub const fn and_hms_nano_opt( &self, hour: u32, min: u32, sec: u32, nano: u32, ) -> Option<NaiveDateTime>

Makes a new NaiveDateTime from the current date, hour, minute, second and nanosecond.

The nanosecond part is allowed to exceed 1,000,000,000 in order to represent a leap second, but only when sec == 59.

Errors

Returns None on invalid hour, minute, second and/or nanosecond.

Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd_opt(2015, 6, 3).unwrap();
assert!(d.and_hms_nano_opt(12, 34, 56, 789_012_345).is_some());
assert!(d.and_hms_nano_opt(12, 34, 59, 1_789_012_345).is_some()); // leap second
assert!(d.and_hms_nano_opt(12, 34, 59, 2_789_012_345).is_none());
assert!(d.and_hms_nano_opt(12, 34, 60, 789_012_345).is_none());
assert!(d.and_hms_nano_opt(12, 60, 56, 789_012_345).is_none());
assert!(d.and_hms_nano_opt(24, 34, 56, 789_012_345).is_none());

const fn mdf(&self) -> Mdf

Returns the packed month-day-flags.

const fn with_mdf(&self, mdf: Mdf) -> Option<NaiveDate>

Makes a new NaiveDate with the packed month-day-flags changed.

Returns None when the resulting NaiveDate would be invalid.

pub const fn succ(&self) -> NaiveDate

👎Deprecated since 0.4.23: use succ_opt() instead

Makes a new NaiveDate for the next calendar date.

Panics

Panics when self is the last representable date.

pub const fn succ_opt(&self) -> Option<NaiveDate>

Makes a new NaiveDate for the next calendar date.

Errors

Returns None when self is the last representable date.

Example

use chrono::NaiveDate;

assert_eq!(
    NaiveDate::from_ymd_opt(2015, 6, 3).unwrap().succ_opt(),
    Some(NaiveDate::from_ymd_opt(2015, 6, 4).unwrap())
);
assert_eq!(NaiveDate::MAX.succ_opt(), None);

pub const fn pred(&self) -> NaiveDate

👎Deprecated since 0.4.23: use pred_opt() instead

Makes a new NaiveDate for the previous calendar date.

Panics

Panics when self is the first representable date.

pub const fn pred_opt(&self) -> Option<NaiveDate>

Makes a new NaiveDate for the previous calendar date.

Errors

Returns None when self is the first representable date.

Example

use chrono::NaiveDate;

assert_eq!(
    NaiveDate::from_ymd_opt(2015, 6, 3).unwrap().pred_opt(),
    Some(NaiveDate::from_ymd_opt(2015, 6, 2).unwrap())
);
assert_eq!(NaiveDate::MIN.pred_opt(), None);

pub const fn checked_add_signed(self, rhs: TimeDelta) -> Option<NaiveDate>

Adds the number of whole days in the given TimeDelta to the current date.

Errors

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

Example

use chrono::{NaiveDate, TimeDelta};

let d = NaiveDate::from_ymd_opt(2015, 9, 5).unwrap();
assert_eq!(
    d.checked_add_signed(TimeDelta::try_days(40).unwrap()),
    Some(NaiveDate::from_ymd_opt(2015, 10, 15).unwrap())
);
assert_eq!(
    d.checked_add_signed(TimeDelta::try_days(-40).unwrap()),
    Some(NaiveDate::from_ymd_opt(2015, 7, 27).unwrap())
);
assert_eq!(d.checked_add_signed(TimeDelta::try_days(1_000_000_000).unwrap()), None);
assert_eq!(d.checked_add_signed(TimeDelta::try_days(-1_000_000_000).unwrap()), None);
assert_eq!(NaiveDate::MAX.checked_add_signed(TimeDelta::try_days(1).unwrap()), None);

pub const fn checked_sub_signed(self, rhs: TimeDelta) -> Option<NaiveDate>

Subtracts the number of whole days in the given TimeDelta from the current date.

Errors

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

Example

use chrono::{NaiveDate, TimeDelta};

let d = NaiveDate::from_ymd_opt(2015, 9, 5).unwrap();
assert_eq!(
    d.checked_sub_signed(TimeDelta::try_days(40).unwrap()),
    Some(NaiveDate::from_ymd_opt(2015, 7, 27).unwrap())
);
assert_eq!(
    d.checked_sub_signed(TimeDelta::try_days(-40).unwrap()),
    Some(NaiveDate::from_ymd_opt(2015, 10, 15).unwrap())
);
assert_eq!(d.checked_sub_signed(TimeDelta::try_days(1_000_000_000).unwrap()), None);
assert_eq!(d.checked_sub_signed(TimeDelta::try_days(-1_000_000_000).unwrap()), None);
assert_eq!(NaiveDate::MIN.checked_sub_signed(TimeDelta::try_days(1).unwrap()), None);

pub const fn signed_duration_since(self, rhs: NaiveDate) -> TimeDelta

Subtracts another NaiveDate from the current date. Returns a TimeDelta of integral numbers.

This does not overflow or underflow at all, as all possible output fits in the range of TimeDelta.

Example

use chrono::{NaiveDate, TimeDelta};

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

assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2014, 1, 1)), TimeDelta::zero());
assert_eq!(
    since(from_ymd(2014, 1, 1), from_ymd(2013, 12, 31)),
    TimeDelta::try_days(1).unwrap()
);
assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2014, 1, 2)), TimeDelta::try_days(-1).unwrap());
assert_eq!(
    since(from_ymd(2014, 1, 1), from_ymd(2013, 9, 23)),
    TimeDelta::try_days(100).unwrap()
);
assert_eq!(
    since(from_ymd(2014, 1, 1), from_ymd(2013, 1, 1)),
    TimeDelta::try_days(365).unwrap()
);
assert_eq!(
    since(from_ymd(2014, 1, 1), from_ymd(2010, 1, 1)),
    TimeDelta::try_days(365 * 4 + 1).unwrap()
);
assert_eq!(
    since(from_ymd(2014, 1, 1), from_ymd(1614, 1, 1)),
    TimeDelta::try_days(365 * 400 + 97).unwrap()
);

pub const fn years_since(&self, base: Self) -> Option<u32>

Returns the number of whole years from the given base until self.

Errors

Returns None if base > self.

pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I>

where I: Iterator<Item = B> + Clone, B: Borrow<Item<'a>>,

Formats the date 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");
let d = NaiveDate::from_ymd_opt(2015, 9, 5).unwrap();
assert_eq!(d.format_with_items(fmt.clone()).to_string(), "2015-09-05");
assert_eq!(d.format("%Y-%m-%d").to_string(), "2015-09-05");

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

assert_eq!(format!("{}", d.format_with_items(fmt)), "2015-09-05");

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

Formats the date 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.)

Panics

Converting or formatting the returned DelayedFormat panics if the format string is wrong. Because of this delayed failure, you are recommended to immediately use the DelayedFormat value.

Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd_opt(2015, 9, 5).unwrap();
assert_eq!(d.format("%Y-%m-%d").to_string(), "2015-09-05");
assert_eq!(d.format("%A, %-d %B, %C%y").to_string(), "Saturday, 5 September, 2015");

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

assert_eq!(format!("{}", d.format("%Y-%m-%d")), "2015-09-05");
assert_eq!(format!("{}", d.format("%A, %-d %B, %C%y")), "Saturday, 5 September, 2015");

pub const fn iter_days(&self) -> NaiveDateDaysIterator

Returns an iterator that steps by days across all representable dates.

Example

let expected = [
    NaiveDate::from_ymd_opt(2016, 2, 27).unwrap(),
    NaiveDate::from_ymd_opt(2016, 2, 28).unwrap(),
    NaiveDate::from_ymd_opt(2016, 2, 29).unwrap(),
    NaiveDate::from_ymd_opt(2016, 3, 1).unwrap(),
];

let mut count = 0;
for (idx, d) in NaiveDate::from_ymd_opt(2016, 2, 27).unwrap().iter_days().take(4).enumerate() {
    assert_eq!(d, expected[idx]);
    count += 1;
}
assert_eq!(count, 4);

for d in NaiveDate::from_ymd_opt(2016, 3, 1).unwrap().iter_days().rev().take(4) {
    count -= 1;
    assert_eq!(d, expected[count]);
}

pub const fn iter_weeks(&self) -> NaiveDateWeeksIterator

Returns an iterator that steps by weeks across all representable dates.

Example

let expected = [
    NaiveDate::from_ymd_opt(2016, 2, 27).unwrap(),
    NaiveDate::from_ymd_opt(2016, 3, 5).unwrap(),
    NaiveDate::from_ymd_opt(2016, 3, 12).unwrap(),
    NaiveDate::from_ymd_opt(2016, 3, 19).unwrap(),
];

let mut count = 0;
for (idx, d) in NaiveDate::from_ymd_opt(2016, 2, 27).unwrap().iter_weeks().take(4).enumerate() {
    assert_eq!(d, expected[idx]);
    count += 1;
}
assert_eq!(count, 4);

for d in NaiveDate::from_ymd_opt(2016, 3, 19).unwrap().iter_weeks().rev().take(4) {
    count -= 1;
    assert_eq!(d, expected[count]);
}

pub const fn week(&self, start: Weekday) -> NaiveWeek

Returns the NaiveWeek that the date belongs to, starting with the Weekday specified.

pub const fn leap_year(&self) -> bool

Returns true if this is a leap year.

assert_eq!(NaiveDate::from_ymd_opt(2000, 1, 1).unwrap().leap_year(), true);
assert_eq!(NaiveDate::from_ymd_opt(2001, 1, 1).unwrap().leap_year(), false);
assert_eq!(NaiveDate::from_ymd_opt(2002, 1, 1).unwrap().leap_year(), false);
assert_eq!(NaiveDate::from_ymd_opt(2003, 1, 1).unwrap().leap_year(), false);
assert_eq!(NaiveDate::from_ymd_opt(2004, 1, 1).unwrap().leap_year(), true);
assert_eq!(NaiveDate::from_ymd_opt(2100, 1, 1).unwrap().leap_year(), false);

const fn year(&self) -> i32

const fn ordinal(&self) -> u32

Returns the day of year starting from 1.

const fn month(&self) -> u32

const fn day(&self) -> u32

pub(super) const fn weekday(&self) -> Weekday

Returns the day of week.

const fn year_flags(&self) -> YearFlags

pub(crate) const fn num_days_from_ce(&self) -> i32

Counts the days in the proleptic Gregorian calendar, with January 1, Year 1 (CE) as day 1.

const fn from_yof(yof: i32) -> NaiveDate

Create a new NaiveDate from a raw year-ordinal-flags i32.

In a valid value an ordinal is never 0, and neither are the year flags. This method doesn’t do any validation in release builds.

const fn yof(&self) -> i32

Get the raw year-ordinal-flags i32.

pub const MIN: NaiveDate = _

The minimum possible NaiveDate (January 1, 262144 BCE).

pub const MAX: NaiveDate = _

The maximum possible NaiveDate (December 31, 262142 CE).

pub(crate) const BEFORE_MIN: NaiveDate = _

One day before the minimum possible NaiveDate (December 31, 262145 BCE).

pub(crate) const AFTER_MAX: NaiveDate = _

One day after the maximum possible NaiveDate (January 1, 262143 CE).

Trait Implementations

impl Add<Days> for NaiveDate

Add Days to NaiveDate.

Panics

Panics if the resulting date would be out of range. Consider using NaiveDate::checked_add_days to get an Option instead.

type Output = NaiveDate

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Months> for NaiveDate

Add Months to NaiveDate.

The result will be clamped to valid days in the resulting month, see checked_add_months for details.

Panics

Panics if the resulting date would be out of range. Consider using NaiveDate::checked_add_months to get an Option instead.

Example

use chrono::{Months, NaiveDate};

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

assert_eq!(from_ymd(2014, 1, 1) + Months::new(1), from_ymd(2014, 2, 1));
assert_eq!(from_ymd(2014, 1, 1) + Months::new(11), from_ymd(2014, 12, 1));
assert_eq!(from_ymd(2014, 1, 1) + Months::new(12), from_ymd(2015, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) + Months::new(13), from_ymd(2015, 2, 1));
assert_eq!(from_ymd(2014, 1, 31) + Months::new(1), from_ymd(2014, 2, 28));
assert_eq!(from_ymd(2020, 1, 31) + Months::new(1), from_ymd(2020, 2, 29));

type Output = NaiveDate

The resulting type after applying the + operator.

fn add(self, months: Months) -> Self::Output

Performs the + operation.

impl Add<TimeDelta> for NaiveDate

Add TimeDelta to NaiveDate.

This discards the fractional days in TimeDelta, rounding to the closest integral number of days towards TimeDelta::zero().

Panics

Panics if the resulting date would be out of range. Consider using NaiveDate::checked_add_signed to get an Option instead.

Example

use chrono::{NaiveDate, TimeDelta};

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

assert_eq!(from_ymd(2014, 1, 1) + TimeDelta::zero(), from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) + TimeDelta::try_seconds(86399).unwrap(), from_ymd(2014, 1, 1));
assert_eq!(
    from_ymd(2014, 1, 1) + TimeDelta::try_seconds(-86399).unwrap(),
    from_ymd(2014, 1, 1)
);
assert_eq!(from_ymd(2014, 1, 1) + TimeDelta::try_days(1).unwrap(), from_ymd(2014, 1, 2));
assert_eq!(from_ymd(2014, 1, 1) + TimeDelta::try_days(-1).unwrap(), from_ymd(2013, 12, 31));
assert_eq!(from_ymd(2014, 1, 1) + TimeDelta::try_days(364).unwrap(), from_ymd(2014, 12, 31));
assert_eq!(
    from_ymd(2014, 1, 1) + TimeDelta::try_days(365 * 4 + 1).unwrap(),
    from_ymd(2018, 1, 1)
);
assert_eq!(
    from_ymd(2014, 1, 1) + TimeDelta::try_days(365 * 400 + 97).unwrap(),
    from_ymd(2414, 1, 1)
);

type Output = NaiveDate

The resulting type after applying the + operator.

fn add(self, rhs: TimeDelta) -> NaiveDate

Performs the + operation.

impl AddAssign<TimeDelta> for NaiveDate

Add-assign of TimeDelta to NaiveDate.

This discards the fractional days in TimeDelta, rounding to the closest integral number of days towards TimeDelta::zero().

Panics

Panics if the resulting date would be out of range. Consider using NaiveDate::checked_add_signed to get an Option instead.

fn add_assign(&mut self, rhs: TimeDelta)

Performs the += operation.

impl Clone for NaiveDate

fn clone(&self) -> NaiveDate

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Datelike for NaiveDate

fn year(&self) -> i32

Returns the year number in the calendar date.

Example

use chrono::{Datelike, NaiveDate};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().year(), 2015);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().year(), -308); // 309 BCE

fn month(&self) -> u32

Returns the month number starting from 1.

The return value ranges from 1 to 12.

Example

use chrono::{Datelike, NaiveDate};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().month(), 9);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().month(), 3);

fn month0(&self) -> u32

Returns the month number starting from 0.

The return value ranges from 0 to 11.

Example

use chrono::{Datelike, NaiveDate};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().month0(), 8);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().month0(), 2);

fn day(&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.)

Example

use chrono::{Datelike, NaiveDate};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().day(), 8);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().day(), 14);

Combined with NaiveDate::pred_opt, one can determine the number of days in a particular month. (Note that this panics when year is out of range.)

use chrono::{Datelike, NaiveDate};

fn ndays_in_month(year: i32, month: u32) -> u32 {
    // the first day of the next month...
    let (y, m) = if month == 12 { (year + 1, 1) } else { (year, month + 1) };
    let d = NaiveDate::from_ymd_opt(y, m, 1).unwrap();

    // ...is preceded by the last day of the original month
    d.pred_opt().unwrap().day()
}

assert_eq!(ndays_in_month(2015, 8), 31);
assert_eq!(ndays_in_month(2015, 9), 30);
assert_eq!(ndays_in_month(2015, 12), 31);
assert_eq!(ndays_in_month(2016, 2), 29);
assert_eq!(ndays_in_month(2017, 2), 28);

fn day0(&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.)

Example

use chrono::{Datelike, NaiveDate};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().day0(), 7);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().day0(), 13);

fn ordinal(&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.)

Example

use chrono::{Datelike, NaiveDate};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().ordinal(), 251);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().ordinal(), 74);

Combined with NaiveDate::pred_opt, one can determine the number of days in a particular year. (Note that this panics when year is out of range.)

use chrono::{Datelike, NaiveDate};

fn ndays_in_year(year: i32) -> u32 {
    // the first day of the next year...
    let d = NaiveDate::from_ymd_opt(year + 1, 1, 1).unwrap();

    // ...is preceded by the last day of the original year
    d.pred_opt().unwrap().ordinal()
}

assert_eq!(ndays_in_year(2015), 365);
assert_eq!(ndays_in_year(2016), 366);
assert_eq!(ndays_in_year(2017), 365);
assert_eq!(ndays_in_year(2000), 366);
assert_eq!(ndays_in_year(2100), 365);

fn ordinal0(&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.)

Example

use chrono::{Datelike, NaiveDate};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().ordinal0(), 250);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().ordinal0(), 73);

fn weekday(&self) -> Weekday

Returns the day of week.

Example

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

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().weekday(), Weekday::Tue);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().weekday(), Weekday::Fri);

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

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

This method assumes you want to work on the date as a year-month-day value. Don’t use it if you want the ordinal to stay the same after changing the year, of if you want the week and weekday values to stay the same.

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.

Examples

use chrono::{Datelike, NaiveDate};

assert_eq!(
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_year(2016),
    Some(NaiveDate::from_ymd_opt(2016, 9, 8).unwrap())
);
assert_eq!(
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_year(-308),
    Some(NaiveDate::from_ymd_opt(-308, 9, 8).unwrap())
);

A leap day (February 29) is a case where this method can return None.

assert!(NaiveDate::from_ymd_opt(2016, 2, 29).unwrap().with_year(2015).is_none());
assert!(NaiveDate::from_ymd_opt(2016, 2, 29).unwrap().with_year(2020).is_some());

Don’t use with_year if you want the ordinal date to stay the same:

assert_ne!(
    NaiveDate::from_yo_opt(2020, 100).unwrap().with_year(2023).unwrap(),
    NaiveDate::from_yo_opt(2023, 100).unwrap() // result is 2023-101
);

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

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

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.

Examples

use chrono::{Datelike, NaiveDate};

assert_eq!(
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_month(10),
    Some(NaiveDate::from_ymd_opt(2015, 10, 8).unwrap())
);
assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_month(13), None); // No month 13
assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 30).unwrap().with_month(2), None); // No Feb 30

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

use chrono::{Datelike, NaiveDate};

fn with_year_month(date: NaiveDate, year: i32, month: u32) -> Option<NaiveDate> {
    date.with_year(year)?.with_month(month)
}
let d = NaiveDate::from_ymd_opt(2020, 2, 29).unwrap();
assert!(with_year_month(d, 2019, 1).is_none()); // fails because of invalid intermediate value

// Correct version:
fn with_year_month_fixed(date: NaiveDate, year: i32, month: u32) -> Option<NaiveDate> {
    NaiveDate::from_ymd_opt(year, month, date.day())
}
let d = NaiveDate::from_ymd_opt(2020, 2, 29).unwrap();
assert_eq!(with_year_month_fixed(d, 2019, 1), NaiveDate::from_ymd_opt(2019, 1, 29));

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

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

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};

assert_eq!(
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_month0(9),
    Some(NaiveDate::from_ymd_opt(2015, 10, 8).unwrap())
);
assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_month0(12), None); // No month 12
assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 30).unwrap().with_month0(1), None); // No Feb 30

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

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

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};

assert_eq!(
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_day(30),
    Some(NaiveDate::from_ymd_opt(2015, 9, 30).unwrap())
);
assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_day(31), None);
// no September 31

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

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

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};

assert_eq!(
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_day0(29),
    Some(NaiveDate::from_ymd_opt(2015, 9, 30).unwrap())
);
assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_day0(30), None);
// no September 31

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

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

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::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd_opt(2015, 1, 1).unwrap().with_ordinal(60),
           Some(NaiveDate::from_ymd_opt(2015, 3, 1).unwrap()));
assert_eq!(NaiveDate::from_ymd_opt(2015, 1, 1).unwrap().with_ordinal(366),
           None); // 2015 had only 365 days

assert_eq!(NaiveDate::from_ymd_opt(2016, 1, 1).unwrap().with_ordinal(60),
           Some(NaiveDate::from_ymd_opt(2016, 2, 29).unwrap()));
assert_eq!(NaiveDate::from_ymd_opt(2016, 1, 1).unwrap().with_ordinal(366),
           Some(NaiveDate::from_ymd_opt(2016, 12, 31).unwrap()));

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

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

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::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd_opt(2015, 1, 1).unwrap().with_ordinal0(59),
           Some(NaiveDate::from_ymd_opt(2015, 3, 1).unwrap()));
assert_eq!(NaiveDate::from_ymd_opt(2015, 1, 1).unwrap().with_ordinal0(365),
           None); // 2015 had only 365 days

assert_eq!(NaiveDate::from_ymd_opt(2016, 1, 1).unwrap().with_ordinal0(59),
           Some(NaiveDate::from_ymd_opt(2016, 2, 29).unwrap()));
assert_eq!(NaiveDate::from_ymd_opt(2016, 1, 1).unwrap().with_ordinal0(365),
           Some(NaiveDate::from_ymd_opt(2016, 12, 31).unwrap()));

fn iso_week(&self) -> IsoWeek

Returns the ISO week.

fn year_ce(&self) -> (bool, u32)

Returns the absolute year number starting from 1 with a boolean flag, which is false when the year predates the epoch (BCE/BC) and true otherwise (CE/AD).

fn num_days_from_ce(&self) -> i32

Counts the days in the proleptic Gregorian calendar, with January 1, Year 1 (CE) as day 1.

impl Debug for NaiveDate

The Debug output of the naive date d is the same as d.format("%Y-%m-%d").

The string printed can be readily parsed via the parse method on str.

Example

use chrono::NaiveDate;

assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(2015, 9, 5).unwrap()), "2015-09-05");
assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(0, 1, 1).unwrap()), "0000-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(9999, 12, 31).unwrap()), "9999-12-31");

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(-1, 1, 1).unwrap()), "-0001-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(10000, 12, 31).unwrap()), "+10000-12-31");

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

Formats the value using the given formatter.

impl Default for NaiveDate

The default value for a NaiveDate is 1st of January 1970.

Example

use chrono::NaiveDate;

let default_date = NaiveDate::default();
assert_eq!(default_date, NaiveDate::from_ymd_opt(1970, 1, 1).unwrap());

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for NaiveDate

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for NaiveDate

The Display output of the naive date d is the same as d.format("%Y-%m-%d").

The string printed can be readily parsed via the parse method on str.

Example

use chrono::NaiveDate;

assert_eq!(format!("{}", NaiveDate::from_ymd_opt(2015, 9, 5).unwrap()), "2015-09-05");
assert_eq!(format!("{}", NaiveDate::from_ymd_opt(0, 1, 1).unwrap()), "0000-01-01");
assert_eq!(format!("{}", NaiveDate::from_ymd_opt(9999, 12, 31).unwrap()), "9999-12-31");

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{}", NaiveDate::from_ymd_opt(-1, 1, 1).unwrap()), "-0001-01-01");
assert_eq!(format!("{}", NaiveDate::from_ymd_opt(10000, 12, 31).unwrap()), "+10000-12-31");

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

Formats the value using the given formatter.

impl From<NaiveDate> 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 From<NaiveDateTime> for NaiveDate

fn from(naive_datetime: NaiveDateTime) -> Self

Converts to this type from the input type.

impl FromStr for NaiveDate

Parsing a str into a NaiveDate uses the same format, %Y-%m-%d, as in Debug and Display.

Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd_opt(2015, 9, 18).unwrap();
assert_eq!("2015-09-18".parse::<NaiveDate>(), Ok(d));

let d = NaiveDate::from_ymd_opt(12345, 6, 7).unwrap();
assert_eq!("+12345-6-7".parse::<NaiveDate>(), Ok(d));

assert!("foo".parse::<NaiveDate>().is_err());

type Err = ParseError

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

impl Hash for NaiveDate

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

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for NaiveDate

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for NaiveDate

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for NaiveDate

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

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for NaiveDate

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<Days> for NaiveDate

Subtract Days from NaiveDate.

Panics

Panics if the resulting date would be out of range. Consider using NaiveDate::checked_sub_days to get an Option instead.

type Output = NaiveDate

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Months> for NaiveDate

Subtract Months from NaiveDate.

The result will be clamped to valid days in the resulting month, see checked_sub_months for details.

Panics

Panics if the resulting date would be out of range. Consider using NaiveDate::checked_sub_months to get an Option instead.

Example

use chrono::{Months, NaiveDate};

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

assert_eq!(from_ymd(2014, 1, 1) - Months::new(11), from_ymd(2013, 2, 1));
assert_eq!(from_ymd(2014, 1, 1) - Months::new(12), from_ymd(2013, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Months::new(13), from_ymd(2012, 12, 1));

type Output = NaiveDate

The resulting type after applying the - operator.

fn sub(self, months: Months) -> Self::Output

Performs the - operation.

impl Sub<TimeDelta> for NaiveDate

Subtract TimeDelta from NaiveDate.

This discards the fractional days in TimeDelta, rounding to the closest integral number of days towards TimeDelta::zero(). It is the same as the addition with a negated TimeDelta.

Panics

Panics if the resulting date would be out of range. Consider using NaiveDate::checked_sub_signed to get an Option instead.

Example

use chrono::{NaiveDate, TimeDelta};

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

assert_eq!(from_ymd(2014, 1, 1) - TimeDelta::zero(), from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - TimeDelta::try_seconds(86399).unwrap(), from_ymd(2014, 1, 1));
assert_eq!(
    from_ymd(2014, 1, 1) - TimeDelta::try_seconds(-86399).unwrap(),
    from_ymd(2014, 1, 1)
);
assert_eq!(from_ymd(2014, 1, 1) - TimeDelta::try_days(1).unwrap(), from_ymd(2013, 12, 31));
assert_eq!(from_ymd(2014, 1, 1) - TimeDelta::try_days(-1).unwrap(), from_ymd(2014, 1, 2));
assert_eq!(from_ymd(2014, 1, 1) - TimeDelta::try_days(364).unwrap(), from_ymd(2013, 1, 2));
assert_eq!(
    from_ymd(2014, 1, 1) - TimeDelta::try_days(365 * 4 + 1).unwrap(),
    from_ymd(2010, 1, 1)
);
assert_eq!(
    from_ymd(2014, 1, 1) - TimeDelta::try_days(365 * 400 + 97).unwrap(),
    from_ymd(1614, 1, 1)
);

type Output = NaiveDate

The resulting type after applying the - operator.

fn sub(self, rhs: TimeDelta) -> NaiveDate

Performs the - operation.

impl Sub for NaiveDate

Subtracts another NaiveDate from the current date. Returns a TimeDelta of integral numbers.

This does not overflow or underflow at all, as all possible output fits in the range of TimeDelta.

The implementation is a wrapper around NaiveDate::signed_duration_since.

Example

use chrono::{NaiveDate, TimeDelta};

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

assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2014, 1, 1), TimeDelta::zero());
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 12, 31), TimeDelta::try_days(1).unwrap());
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2014, 1, 2), TimeDelta::try_days(-1).unwrap());
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 9, 23), TimeDelta::try_days(100).unwrap());
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 1, 1), TimeDelta::try_days(365).unwrap());
assert_eq!(
    from_ymd(2014, 1, 1) - from_ymd(2010, 1, 1),
    TimeDelta::try_days(365 * 4 + 1).unwrap()
);
assert_eq!(
    from_ymd(2014, 1, 1) - from_ymd(1614, 1, 1),
    TimeDelta::try_days(365 * 400 + 97).unwrap()
);

type Output = TimeDelta

The resulting type after applying the - operator.

fn sub(self, rhs: NaiveDate) -> TimeDelta

Performs the - operation.

impl SubAssign<TimeDelta> for NaiveDate

Subtract-assign TimeDelta from NaiveDate.

This discards the fractional days in TimeDelta, rounding to the closest integral number of days towards TimeDelta::zero(). It is the same as the addition with a negated TimeDelta.

Panics

Panics if the resulting date would be out of range. Consider using NaiveDate::checked_sub_signed to get an Option instead.

fn sub_assign(&mut self, rhs: TimeDelta)

Performs the -= operation.

impl Copy for NaiveDate

impl Eq for NaiveDate

impl StructuralPartialEq for NaiveDate