pub struct NaiveDate { /* private fields */ }
Expand description
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.
Implementations
sourceimpl NaiveDate
impl NaiveDate
sourcepub fn from_ymd(year: i32, month: u32, day: u32) -> NaiveDate
pub fn from_ymd(year: i32, month: u32, day: u32) -> NaiveDate
Makes a new NaiveDate
from the calendar date
(year, month and day).
Panics on the out-of-range date, invalid month and/or day.
Example
use chrono::{NaiveDate, Datelike, Weekday};
let d = NaiveDate::from_ymd(2015, 3, 14);
assert_eq!(d.year(), 2015);
assert_eq!(d.month(), 3);
assert_eq!(d.day(), 14);
assert_eq!(d.ordinal(), 73); // day of year
assert_eq!(d.iso_week().year(), 2015);
assert_eq!(d.iso_week().week(), 11);
assert_eq!(d.weekday(), Weekday::Sat);
assert_eq!(d.num_days_from_ce(), 735671); // days since January 1, 1 CE
sourcepub fn from_ymd_opt(year: i32, month: u32, day: u32) -> Option<NaiveDate>
pub fn from_ymd_opt(year: i32, month: u32, day: u32) -> Option<NaiveDate>
Makes a new NaiveDate
from the calendar date
(year, month and day).
Returns None
on the out-of-range date, invalid month and/or day.
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());
sourcepub fn from_yo(year: i32, ordinal: u32) -> NaiveDate
pub fn from_yo(year: i32, ordinal: u32) -> NaiveDate
Makes a new NaiveDate
from the ordinal date
(year and day of the year).
Panics on the out-of-range date and/or invalid day of year.
Example
use chrono::{NaiveDate, Datelike, Weekday};
let d = NaiveDate::from_yo(2015, 73);
assert_eq!(d.ordinal(), 73);
assert_eq!(d.year(), 2015);
assert_eq!(d.month(), 3);
assert_eq!(d.day(), 14);
assert_eq!(d.iso_week().year(), 2015);
assert_eq!(d.iso_week().week(), 11);
assert_eq!(d.weekday(), Weekday::Sat);
assert_eq!(d.num_days_from_ce(), 735671); // days since January 1, 1 CE
sourcepub fn from_yo_opt(year: i32, ordinal: u32) -> Option<NaiveDate>
pub fn from_yo_opt(year: i32, ordinal: u32) -> Option<NaiveDate>
Makes a new NaiveDate
from the ordinal date
(year and day of the year).
Returns None
on the out-of-range date and/or invalid day of year.
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());
sourcepub fn from_isoywd(year: i32, week: u32, weekday: Weekday) -> NaiveDate
pub fn from_isoywd(year: i32, week: u32, weekday: Weekday) -> 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.
Panics on the out-of-range date and/or invalid week number.
Example
use chrono::{NaiveDate, Datelike, Weekday};
let d = NaiveDate::from_isoywd(2015, 11, Weekday::Sat);
assert_eq!(d.iso_week().year(), 2015);
assert_eq!(d.iso_week().week(), 11);
assert_eq!(d.weekday(), Weekday::Sat);
assert_eq!(d.year(), 2015);
assert_eq!(d.month(), 3);
assert_eq!(d.day(), 14);
assert_eq!(d.ordinal(), 73); // day of year
assert_eq!(d.num_days_from_ce(), 735671); // days since January 1, 1 CE
sourcepub fn from_isoywd_opt(
year: i32,
week: u32,
weekday: Weekday
) -> Option<NaiveDate>
pub 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.
Returns None
on the out-of-range date and/or invalid week number.
Example
use chrono::{NaiveDate, Weekday};
let from_ymd = NaiveDate::from_ymd;
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)));
sourcepub fn from_num_days_from_ce(days: i32) -> NaiveDate
pub fn from_num_days_from_ce(days: i32) -> NaiveDate
Makes a new NaiveDate
from a day’s number in the proleptic Gregorian calendar, with
January 1, 1 being day 1.
Panics if the date is out of range.
Example
use chrono::{NaiveDate, Datelike, Weekday};
let d = NaiveDate::from_num_days_from_ce(735671);
assert_eq!(d.num_days_from_ce(), 735671); // days since January 1, 1 CE
assert_eq!(d.year(), 2015);
assert_eq!(d.month(), 3);
assert_eq!(d.day(), 14);
assert_eq!(d.ordinal(), 73); // day of year
assert_eq!(d.iso_week().year(), 2015);
assert_eq!(d.iso_week().week(), 11);
assert_eq!(d.weekday(), Weekday::Sat);
While not directly supported by Chrono,
it is easy to convert from the Julian day number
(January 1, 4713 BCE in the Julian calendar being Day 0)
to Gregorian with this method.
(Note that this panics when jd
is out of range.)
use chrono::NaiveDate;
fn jd_to_date(jd: i32) -> NaiveDate {
// keep in mind that the Julian day number is 0-based
// while this method requires an 1-based number.
NaiveDate::from_num_days_from_ce(jd - 1721425)
}
// January 1, 4713 BCE in Julian = November 24, 4714 BCE in Gregorian
assert_eq!(jd_to_date(0), NaiveDate::from_ymd(-4713, 11, 24));
assert_eq!(jd_to_date(1721426), NaiveDate::from_ymd(1, 1, 1));
assert_eq!(jd_to_date(2450000), NaiveDate::from_ymd(1995, 10, 9));
assert_eq!(jd_to_date(2451545), NaiveDate::from_ymd(2000, 1, 1));
sourcepub fn from_num_days_from_ce_opt(days: i32) -> Option<NaiveDate>
pub 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.
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 = NaiveDate::from_ymd;
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);
sourcepub fn from_weekday_of_month(
year: i32,
month: u32,
weekday: Weekday,
n: u8
) -> NaiveDate
pub fn from_weekday_of_month(
year: i32,
month: u32,
weekday: Weekday,
n: u8
) -> 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)
.
Panics
The resulting NaiveDate
is guaranteed to be in month
. If n
is larger than the number
of weekday
in month
(eg. the 6th Friday of March 2017) then this function will panic.
n
is 1-indexed. Passing n=0
will cause a panic.
Example
use chrono::{NaiveDate, Weekday};
let from_weekday_of_month = NaiveDate::from_weekday_of_month;
let from_ymd = NaiveDate::from_ymd;
assert_eq!(from_weekday_of_month(2018, 8, Weekday::Wed, 1), from_ymd(2018, 8, 1));
assert_eq!(from_weekday_of_month(2018, 8, Weekday::Fri, 1), from_ymd(2018, 8, 3));
assert_eq!(from_weekday_of_month(2018, 8, Weekday::Tue, 2), from_ymd(2018, 8, 14));
assert_eq!(from_weekday_of_month(2018, 8, Weekday::Fri, 4), from_ymd(2018, 8, 24));
assert_eq!(from_weekday_of_month(2018, 8, Weekday::Fri, 5), from_ymd(2018, 8, 31));
sourcepub fn from_weekday_of_month_opt(
year: i32,
month: u32,
weekday: Weekday,
n: u8
) -> Option<NaiveDate>
pub 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.
use chrono::{NaiveDate, Weekday};
assert_eq!(NaiveDate::from_weekday_of_month_opt(2017, 3, Weekday::Fri, 2),
NaiveDate::from_ymd_opt(2017, 3, 10))
Returns None
if n
out-of-range; ie. if n
is larger than the number of weekday
in
month
(eg. the 6th Friday of March 2017), or if n == 0
.
sourcepub fn parse_from_str(s: &str, fmt: &str) -> ParseResult<NaiveDate>
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(2015, 9, 5)));
assert_eq!(parse_from_str("5sep2015", "%d%b%Y"),
Ok(NaiveDate::from_ymd(2015, 9, 5)));
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(2014, 5, 17)));
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());
sourcepub fn and_time(&self, time: NaiveTime) -> NaiveDateTime
pub fn and_time(&self, time: NaiveTime) -> NaiveDateTime
Makes a new NaiveDateTime
from the current date and given NaiveTime
.
Example
use chrono::{NaiveDate, NaiveTime, NaiveDateTime};
let d = NaiveDate::from_ymd(2015, 6, 3);
let t = NaiveTime::from_hms_milli(12, 34, 56, 789);
let dt: NaiveDateTime = d.and_time(t);
assert_eq!(dt.date(), d);
assert_eq!(dt.time(), t);
sourcepub fn and_hms(&self, hour: u32, min: u32, sec: u32) -> NaiveDateTime
pub fn and_hms(&self, hour: u32, min: u32, sec: u32) -> NaiveDateTime
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 on invalid hour, minute and/or second.
Example
use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday};
let d = NaiveDate::from_ymd(2015, 6, 3);
let dt: NaiveDateTime = d.and_hms(12, 34, 56);
assert_eq!(dt.year(), 2015);
assert_eq!(dt.weekday(), Weekday::Wed);
assert_eq!(dt.second(), 56);
sourcepub fn and_hms_opt(
&self,
hour: u32,
min: u32,
sec: u32
) -> Option<NaiveDateTime>
pub 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.
Returns None
on invalid hour, minute and/or second.
Example
use chrono::NaiveDate;
let d = NaiveDate::from_ymd(2015, 6, 3);
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());
sourcepub fn and_hms_milli(
&self,
hour: u32,
min: u32,
sec: u32,
milli: u32
) -> NaiveDateTime
pub fn and_hms_milli(
&self,
hour: u32,
min: u32,
sec: u32,
milli: u32
) -> NaiveDateTime
Makes a new NaiveDateTime
from the current date, hour, minute, second and millisecond.
The millisecond part can exceed 1,000 in order to represent the leap second.
Panics on invalid hour, minute, second and/or millisecond.
Example
use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday};
let d = NaiveDate::from_ymd(2015, 6, 3);
let dt: NaiveDateTime = d.and_hms_milli(12, 34, 56, 789);
assert_eq!(dt.year(), 2015);
assert_eq!(dt.weekday(), Weekday::Wed);
assert_eq!(dt.second(), 56);
assert_eq!(dt.nanosecond(), 789_000_000);
sourcepub fn and_hms_milli_opt(
&self,
hour: u32,
min: u32,
sec: u32,
milli: u32
) -> Option<NaiveDateTime>
pub 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 can exceed 1,000 in order to represent the leap second.
Returns None
on invalid hour, minute, second and/or millisecond.
Example
use chrono::NaiveDate;
let d = NaiveDate::from_ymd(2015, 6, 3);
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());
sourcepub fn and_hms_micro(
&self,
hour: u32,
min: u32,
sec: u32,
micro: u32
) -> NaiveDateTime
pub fn and_hms_micro(
&self,
hour: u32,
min: u32,
sec: u32,
micro: u32
) -> NaiveDateTime
Makes a new NaiveDateTime
from the current date, hour, minute, second and microsecond.
The microsecond part can exceed 1,000,000 in order to represent the leap second.
Panics on invalid hour, minute, second and/or microsecond.
Example
use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday};
let d = NaiveDate::from_ymd(2015, 6, 3);
let dt: NaiveDateTime = d.and_hms_micro(12, 34, 56, 789_012);
assert_eq!(dt.year(), 2015);
assert_eq!(dt.weekday(), Weekday::Wed);
assert_eq!(dt.second(), 56);
assert_eq!(dt.nanosecond(), 789_012_000);
sourcepub fn and_hms_micro_opt(
&self,
hour: u32,
min: u32,
sec: u32,
micro: u32
) -> Option<NaiveDateTime>
pub 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 can exceed 1,000,000 in order to represent the leap second.
Returns None
on invalid hour, minute, second and/or microsecond.
Example
use chrono::NaiveDate;
let d = NaiveDate::from_ymd(2015, 6, 3);
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());
sourcepub fn and_hms_nano(
&self,
hour: u32,
min: u32,
sec: u32,
nano: u32
) -> NaiveDateTime
pub fn and_hms_nano(
&self,
hour: u32,
min: u32,
sec: u32,
nano: u32
) -> NaiveDateTime
Makes a new NaiveDateTime
from the current date, hour, minute, second and nanosecond.
The nanosecond part can exceed 1,000,000,000 in order to represent the leap second.
Panics on invalid hour, minute, second and/or nanosecond.
Example
use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday};
let d = NaiveDate::from_ymd(2015, 6, 3);
let dt: NaiveDateTime = d.and_hms_nano(12, 34, 56, 789_012_345);
assert_eq!(dt.year(), 2015);
assert_eq!(dt.weekday(), Weekday::Wed);
assert_eq!(dt.second(), 56);
assert_eq!(dt.nanosecond(), 789_012_345);
sourcepub fn and_hms_nano_opt(
&self,
hour: u32,
min: u32,
sec: u32,
nano: u32
) -> Option<NaiveDateTime>
pub 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 can exceed 1,000,000,000 in order to represent the leap second.
Returns None
on invalid hour, minute, second and/or nanosecond.
Example
use chrono::NaiveDate;
let d = NaiveDate::from_ymd(2015, 6, 3);
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());
sourcepub fn succ(&self) -> NaiveDate
pub fn succ(&self) -> NaiveDate
Makes a new NaiveDate
for the next calendar date.
Panics when self
is the last representable date.
Example
use chrono::NaiveDate;
assert_eq!(NaiveDate::from_ymd(2015, 6, 3).succ(), NaiveDate::from_ymd(2015, 6, 4));
assert_eq!(NaiveDate::from_ymd(2015, 6, 30).succ(), NaiveDate::from_ymd(2015, 7, 1));
assert_eq!(NaiveDate::from_ymd(2015, 12, 31).succ(), NaiveDate::from_ymd(2016, 1, 1));
sourcepub fn succ_opt(&self) -> Option<NaiveDate>
pub fn succ_opt(&self) -> Option<NaiveDate>
Makes a new NaiveDate
for the next calendar date.
Returns None
when self
is the last representable date.
Example
use chrono::NaiveDate;
use chrono::naive::MAX_DATE;
assert_eq!(NaiveDate::from_ymd(2015, 6, 3).succ_opt(),
Some(NaiveDate::from_ymd(2015, 6, 4)));
assert_eq!(MAX_DATE.succ_opt(), None);
sourcepub fn pred(&self) -> NaiveDate
pub fn pred(&self) -> NaiveDate
Makes a new NaiveDate
for the previous calendar date.
Panics when self
is the first representable date.
Example
use chrono::NaiveDate;
assert_eq!(NaiveDate::from_ymd(2015, 6, 3).pred(), NaiveDate::from_ymd(2015, 6, 2));
assert_eq!(NaiveDate::from_ymd(2015, 6, 1).pred(), NaiveDate::from_ymd(2015, 5, 31));
assert_eq!(NaiveDate::from_ymd(2015, 1, 1).pred(), NaiveDate::from_ymd(2014, 12, 31));
sourcepub fn pred_opt(&self) -> Option<NaiveDate>
pub fn pred_opt(&self) -> Option<NaiveDate>
Makes a new NaiveDate
for the previous calendar date.
Returns None
when self
is the first representable date.
Example
use chrono::NaiveDate;
use chrono::naive::MIN_DATE;
assert_eq!(NaiveDate::from_ymd(2015, 6, 3).pred_opt(),
Some(NaiveDate::from_ymd(2015, 6, 2)));
assert_eq!(MIN_DATE.pred_opt(), None);
sourcepub fn checked_add_signed(self, rhs: OldDuration) -> Option<NaiveDate>
pub fn checked_add_signed(self, rhs: OldDuration) -> Option<NaiveDate>
Adds the days
part of given Duration
to the current date.
Returns None
when it will result in overflow.
Example
use chrono::{Duration, NaiveDate};
use chrono::naive::MAX_DATE;
let d = NaiveDate::from_ymd(2015, 9, 5);
assert_eq!(d.checked_add_signed(Duration::days(40)),
Some(NaiveDate::from_ymd(2015, 10, 15)));
assert_eq!(d.checked_add_signed(Duration::days(-40)),
Some(NaiveDate::from_ymd(2015, 7, 27)));
assert_eq!(d.checked_add_signed(Duration::days(1_000_000_000)), None);
assert_eq!(d.checked_add_signed(Duration::days(-1_000_000_000)), None);
assert_eq!(MAX_DATE.checked_add_signed(Duration::days(1)), None);
sourcepub fn checked_sub_signed(self, rhs: OldDuration) -> Option<NaiveDate>
pub fn checked_sub_signed(self, rhs: OldDuration) -> Option<NaiveDate>
Subtracts the days
part of given Duration
from the current date.
Returns None
when it will result in overflow.
Example
use chrono::{Duration, NaiveDate};
use chrono::naive::MIN_DATE;
let d = NaiveDate::from_ymd(2015, 9, 5);
assert_eq!(d.checked_sub_signed(Duration::days(40)),
Some(NaiveDate::from_ymd(2015, 7, 27)));
assert_eq!(d.checked_sub_signed(Duration::days(-40)),
Some(NaiveDate::from_ymd(2015, 10, 15)));
assert_eq!(d.checked_sub_signed(Duration::days(1_000_000_000)), None);
assert_eq!(d.checked_sub_signed(Duration::days(-1_000_000_000)), None);
assert_eq!(MIN_DATE.checked_sub_signed(Duration::days(1)), None);
sourcepub fn signed_duration_since(self, rhs: NaiveDate) -> OldDuration
pub fn signed_duration_since(self, rhs: NaiveDate) -> OldDuration
Subtracts another NaiveDate
from the current date.
Returns a Duration
of integral numbers.
This does not overflow or underflow at all,
as all possible output fits in the range of Duration
.
Example
use chrono::{Duration, NaiveDate};
let from_ymd = NaiveDate::from_ymd;
let since = NaiveDate::signed_duration_since;
assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2014, 1, 1)), Duration::zero());
assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2013, 12, 31)), Duration::days(1));
assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2014, 1, 2)), Duration::days(-1));
assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2013, 9, 23)), Duration::days(100));
assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2013, 1, 1)), Duration::days(365));
assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2010, 1, 1)), Duration::days(365*4 + 1));
assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(1614, 1, 1)), Duration::days(365*400 + 97));
sourcepub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I> where
I: Iterator<Item = B> + Clone,
B: Borrow<Item<'a>>,
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 Clone
able,
since the resulting DelayedFormat
value may be formatted multiple times.
Example
use chrono::NaiveDate;
use chrono::format::strftime::StrftimeItems;
let fmt = StrftimeItems::new("%Y-%m-%d");
let d = NaiveDate::from_ymd(2015, 9, 5);
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");
sourcepub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>
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.)
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 d = NaiveDate::from_ymd(2015, 9, 5);
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");
sourcepub fn iter_days(&self) -> NaiveDateDaysIterator
pub fn iter_days(&self) -> NaiveDateDaysIterator
Returns an iterator that steps by days until the last representable date.
Example
let expected = [
NaiveDate::from_ymd(2016, 2, 27),
NaiveDate::from_ymd(2016, 2, 28),
NaiveDate::from_ymd(2016, 2, 29),
NaiveDate::from_ymd(2016, 3, 1),
];
let mut count = 0;
for (idx, d) in NaiveDate::from_ymd(2016, 2, 27).iter_days().take(4).enumerate() {
assert_eq!(d, expected[idx]);
count += 1;
}
assert_eq!(count, 4);
sourcepub fn iter_weeks(&self) -> NaiveDateWeeksIterator
pub fn iter_weeks(&self) -> NaiveDateWeeksIterator
Returns an iterator that steps by weeks until the last representable date.
Example
let expected = [
NaiveDate::from_ymd(2016, 2, 27),
NaiveDate::from_ymd(2016, 3, 5),
NaiveDate::from_ymd(2016, 3, 12),
NaiveDate::from_ymd(2016, 3, 19),
];
let mut count = 0;
for (idx, d) in NaiveDate::from_ymd(2016, 2, 27).iter_weeks().take(4).enumerate() {
assert_eq!(d, expected[idx]);
count += 1;
}
assert_eq!(count, 4);
Trait Implementations
sourceimpl Add<Duration> for NaiveDate
impl Add<Duration> for NaiveDate
An addition of Duration
to NaiveDate
discards the fractional days,
rounding to the closest integral number of days towards Duration::zero()
.
Panics on underflow or overflow.
Use NaiveDate::checked_add_signed
to detect that.
Example
use chrono::{Duration, NaiveDate};
let from_ymd = NaiveDate::from_ymd;
assert_eq!(from_ymd(2014, 1, 1) + Duration::zero(), from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) + Duration::seconds(86399), from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) + Duration::seconds(-86399), from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) + Duration::days(1), from_ymd(2014, 1, 2));
assert_eq!(from_ymd(2014, 1, 1) + Duration::days(-1), from_ymd(2013, 12, 31));
assert_eq!(from_ymd(2014, 1, 1) + Duration::days(364), from_ymd(2014, 12, 31));
assert_eq!(from_ymd(2014, 1, 1) + Duration::days(365*4 + 1), from_ymd(2018, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) + Duration::days(365*400 + 97), from_ymd(2414, 1, 1));
sourceimpl AddAssign<Duration> for NaiveDate
impl AddAssign<Duration> for NaiveDate
sourcefn add_assign(&mut self, rhs: OldDuration)
fn add_assign(&mut self, rhs: OldDuration)
Performs the +=
operation. Read more
sourceimpl Datelike for NaiveDate
impl Datelike for NaiveDate
sourcefn year(&self) -> i32
fn year(&self) -> i32
Returns the year number in the calendar date.
Example
use chrono::{NaiveDate, Datelike};
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).year(), 2015);
assert_eq!(NaiveDate::from_ymd(-308, 3, 14).year(), -308); // 309 BCE
sourcefn month(&self) -> u32
fn month(&self) -> u32
Returns the month number starting from 1.
The return value ranges from 1 to 12.
Example
use chrono::{NaiveDate, Datelike};
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).month(), 9);
assert_eq!(NaiveDate::from_ymd(-308, 3, 14).month(), 3);
sourcefn month0(&self) -> u32
fn month0(&self) -> u32
Returns the month number starting from 0.
The return value ranges from 0 to 11.
Example
use chrono::{NaiveDate, Datelike};
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).month0(), 8);
assert_eq!(NaiveDate::from_ymd(-308, 3, 14).month0(), 2);
sourcefn day(&self) -> u32
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::{NaiveDate, Datelike};
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).day(), 8);
assert_eq!(NaiveDate::from_ymd(-308, 3, 14).day(), 14);
Combined with NaiveDate::pred
,
one can determine the number of days in a particular month.
(Note that this panics when year
is out of range.)
use chrono::{NaiveDate, Datelike};
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(y, m, 1);
// ...is preceded by the last day of the original month
d.pred().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);
sourcefn day0(&self) -> u32
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::{NaiveDate, Datelike};
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).day0(), 7);
assert_eq!(NaiveDate::from_ymd(-308, 3, 14).day0(), 13);
sourcefn ordinal(&self) -> u32
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::{NaiveDate, Datelike};
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).ordinal(), 251);
assert_eq!(NaiveDate::from_ymd(-308, 3, 14).ordinal(), 74);
Combined with NaiveDate::pred
,
one can determine the number of days in a particular year.
(Note that this panics when year
is out of range.)
use chrono::{NaiveDate, Datelike};
fn ndays_in_year(year: i32) -> u32 {
// the first day of the next year...
let d = NaiveDate::from_ymd(year + 1, 1, 1);
// ...is preceded by the last day of the original year
d.pred().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);
sourcefn ordinal0(&self) -> u32
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::{NaiveDate, Datelike};
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).ordinal0(), 250);
assert_eq!(NaiveDate::from_ymd(-308, 3, 14).ordinal0(), 73);
sourcefn weekday(&self) -> Weekday
fn weekday(&self) -> Weekday
Returns the day of week.
Example
use chrono::{NaiveDate, Datelike, Weekday};
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).weekday(), Weekday::Tue);
assert_eq!(NaiveDate::from_ymd(-308, 3, 14).weekday(), Weekday::Fri);
sourcefn with_year(&self, year: i32) -> Option<NaiveDate>
fn with_year(&self, year: i32) -> Option<NaiveDate>
Makes a new NaiveDate
with the year number changed.
Returns None
when the resulting NaiveDate
would be invalid.
Example
use chrono::{NaiveDate, Datelike};
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_year(2016),
Some(NaiveDate::from_ymd(2016, 9, 8)));
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_year(-308),
Some(NaiveDate::from_ymd(-308, 9, 8)));
A leap day (February 29) is a good example that this method can return None
.
assert!(NaiveDate::from_ymd(2016, 2, 29).with_year(2015).is_none());
assert!(NaiveDate::from_ymd(2016, 2, 29).with_year(2020).is_some());
sourcefn with_month(&self, month: u32) -> Option<NaiveDate>
fn with_month(&self, month: u32) -> Option<NaiveDate>
Makes a new NaiveDate
with the month number (starting from 1) changed.
Returns None
when the resulting NaiveDate
would be invalid.
Example
use chrono::{NaiveDate, Datelike};
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month(10),
Some(NaiveDate::from_ymd(2015, 10, 8)));
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month(13), None); // no month 13
assert_eq!(NaiveDate::from_ymd(2015, 9, 30).with_month(2), None); // no February 30
sourcefn with_month0(&self, month0: u32) -> Option<NaiveDate>
fn with_month0(&self, month0: u32) -> Option<NaiveDate>
Makes a new NaiveDate
with the month number (starting from 0) changed.
Returns None
when the resulting NaiveDate
would be invalid.
Example
use chrono::{NaiveDate, Datelike};
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month0(9),
Some(NaiveDate::from_ymd(2015, 10, 8)));
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month0(12), None); // no month 13
assert_eq!(NaiveDate::from_ymd(2015, 9, 30).with_month0(1), None); // no February 30
sourcefn with_day(&self, day: u32) -> Option<NaiveDate>
fn with_day(&self, day: u32) -> Option<NaiveDate>
Makes a new NaiveDate
with the day of month (starting from 1) changed.
Returns None
when the resulting NaiveDate
would be invalid.
Example
use chrono::{NaiveDate, Datelike};
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day(30),
Some(NaiveDate::from_ymd(2015, 9, 30)));
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day(31),
None); // no September 31
sourcefn with_day0(&self, day0: u32) -> Option<NaiveDate>
fn with_day0(&self, day0: u32) -> Option<NaiveDate>
Makes a new NaiveDate
with the day of month (starting from 0) changed.
Returns None
when the resulting NaiveDate
would be invalid.
Example
use chrono::{NaiveDate, Datelike};
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day0(29),
Some(NaiveDate::from_ymd(2015, 9, 30)));
assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day0(30),
None); // no September 31
sourcefn with_ordinal(&self, ordinal: u32) -> Option<NaiveDate>
fn with_ordinal(&self, ordinal: u32) -> Option<NaiveDate>
Makes a new NaiveDate
with the day of year (starting from 1) changed.
Returns None
when the resulting NaiveDate
would be invalid.
Example
use chrono::{NaiveDate, Datelike};
assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal(60),
Some(NaiveDate::from_ymd(2015, 3, 1)));
assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal(366),
None); // 2015 had only 365 days
assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal(60),
Some(NaiveDate::from_ymd(2016, 2, 29)));
assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal(366),
Some(NaiveDate::from_ymd(2016, 12, 31)));
sourcefn with_ordinal0(&self, ordinal0: u32) -> Option<NaiveDate>
fn with_ordinal0(&self, ordinal0: u32) -> Option<NaiveDate>
Makes a new NaiveDate
with the day of year (starting from 0) changed.
Returns None
when the resulting NaiveDate
would be invalid.
Example
use chrono::{NaiveDate, Datelike};
assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal0(59),
Some(NaiveDate::from_ymd(2015, 3, 1)));
assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal0(365),
None); // 2015 had only 365 days
assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal0(59),
Some(NaiveDate::from_ymd(2016, 2, 29)));
assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal0(365),
Some(NaiveDate::from_ymd(2016, 12, 31)));
sourcefn year_ce(&self) -> (bool, u32)
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). Read more
sourcefn num_days_from_ce(&self) -> i32
fn num_days_from_ce(&self) -> i32
Counts the days in the proleptic Gregorian calendar, with January 1, Year 1 (CE) as day 1. Read more
sourceimpl Debug for NaiveDate
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(2015, 9, 5)), "2015-09-05");
assert_eq!(format!("{:?}", NaiveDate::from_ymd( 0, 1, 1)), "0000-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(9999, 12, 31)), "9999-12-31");
ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.
assert_eq!(format!("{:?}", NaiveDate::from_ymd( -1, 1, 1)), "-0001-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(10000, 12, 31)), "+10000-12-31");
sourceimpl<'de> Deserialize<'de> for NaiveDate
impl<'de> Deserialize<'de> for NaiveDate
sourcefn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
sourceimpl Display for NaiveDate
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(2015, 9, 5)), "2015-09-05");
assert_eq!(format!("{}", NaiveDate::from_ymd( 0, 1, 1)), "0000-01-01");
assert_eq!(format!("{}", NaiveDate::from_ymd(9999, 12, 31)), "9999-12-31");
ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.
assert_eq!(format!("{}", NaiveDate::from_ymd( -1, 1, 1)), "-0001-01-01");
assert_eq!(format!("{}", NaiveDate::from_ymd(10000, 12, 31)), "+10000-12-31");
sourceimpl FromStr for NaiveDate
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(2015, 9, 18);
assert_eq!("2015-09-18".parse::<NaiveDate>(), Ok(d));
let d = NaiveDate::from_ymd(12345, 6, 7);
assert_eq!("+12345-6-7".parse::<NaiveDate>(), Ok(d));
assert!("foo".parse::<NaiveDate>().is_err());
type Err = ParseError
type Err = ParseError
The associated error which can be returned from parsing.
sourceimpl Ord for NaiveDate
impl Ord for NaiveDate
sourceimpl PartialOrd<NaiveDate> for NaiveDate
impl PartialOrd<NaiveDate> for NaiveDate
sourcefn partial_cmp(&self, other: &NaiveDate) -> Option<Ordering>
fn partial_cmp(&self, other: &NaiveDate) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl Sub<Duration> for NaiveDate
impl Sub<Duration> for NaiveDate
A subtraction of Duration
from NaiveDate
discards the fractional days,
rounding to the closest integral number of days towards Duration::zero()
.
It is the same as the addition with a negated Duration
.
Panics on underflow or overflow.
Use NaiveDate::checked_sub_signed
to detect that.
Example
use chrono::{Duration, NaiveDate};
let from_ymd = NaiveDate::from_ymd;
assert_eq!(from_ymd(2014, 1, 1) - Duration::zero(), from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Duration::seconds(86399), from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Duration::seconds(-86399), from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(1), from_ymd(2013, 12, 31));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(-1), from_ymd(2014, 1, 2));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(364), from_ymd(2013, 1, 2));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(365*4 + 1), from_ymd(2010, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(365*400 + 97), from_ymd(1614, 1, 1));
sourceimpl Sub<NaiveDate> for NaiveDate
impl Sub<NaiveDate> for NaiveDate
Subtracts another NaiveDate
from the current date.
Returns a Duration
of integral numbers.
This does not overflow or underflow at all,
as all possible output fits in the range of Duration
.
The implementation is a wrapper around
NaiveDate::signed_duration_since
.
Example
use chrono::{Duration, NaiveDate};
let from_ymd = NaiveDate::from_ymd;
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2014, 1, 1), Duration::zero());
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 12, 31), Duration::days(1));
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2014, 1, 2), Duration::days(-1));
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 9, 23), Duration::days(100));
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 1, 1), Duration::days(365));
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2010, 1, 1), Duration::days(365*4 + 1));
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(1614, 1, 1), Duration::days(365*400 + 97));
type Output = OldDuration
type Output = OldDuration
The resulting type after applying the -
operator.
sourcefn sub(self, rhs: NaiveDate) -> OldDuration
fn sub(self, rhs: NaiveDate) -> OldDuration
Performs the -
operation. Read more
sourceimpl SubAssign<Duration> for NaiveDate
impl SubAssign<Duration> for NaiveDate
sourcefn sub_assign(&mut self, rhs: OldDuration)
fn sub_assign(&mut self, rhs: OldDuration)
Performs the -=
operation. Read more
impl Copy for NaiveDate
impl Eq for NaiveDate
impl StructuralEq for NaiveDate
impl StructuralPartialEq for NaiveDate
Auto Trait Implementations
impl RefUnwindSafe for NaiveDate
impl Send for NaiveDate
impl Sync for NaiveDate
impl Unpin for NaiveDate
impl UnwindSafe for NaiveDate
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more