Struct chrono::naive::datetime::NaiveDateTime

pub struct NaiveDateTime { /* fields omitted */ }

ISO 8601 combined date and time without timezone.

Methods

impl NaiveDateTime

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

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

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

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

Panics on the out-of-range number of seconds and/or invalid nanosecond.

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

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

Returns None on the out-of-range number of seconds and/or invalid nanosecond.

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

Deprecated: Same to NaiveDateTime::from_timestamp.

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

Deprecated: Same to NaiveDateTime::from_timestamp_opt.

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

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

fn date(&self) -> NaiveDate

Retrieves a date component.

fn time(&self) -> NaiveTime

Retrieves a time component.

fn timestamp(&self) -> i64

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

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

fn timestamp_subsec_millis(&self) -> u32

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

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

fn timestamp_subsec_micros(&self) -> u32

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

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

fn timestamp_subsec_nanos(&self) -> u32

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

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

fn num_seconds_from_unix_epoch(&self) -> i64

Deprecated: Same to NaiveDateTime::timestamp.

fn checked_add(self, rhs: Duration) -> Option<NaiveDateTime>

Adds given Duration to the current date and time.

Returns None when it will result in overflow.

fn checked_sub(self, rhs: Duration) -> Option<NaiveDateTime>

Subtracts given Duration from the current date and time.

Returns None when it will result in overflow.

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

Formats the combined date and time with the specified formatting items.

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

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

Trait Implementations

impl PartialEq for NaiveDateTime

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &NaiveDateTime) -> bool

This method tests for !=.

impl Eq for NaiveDateTime

impl PartialOrd for NaiveDateTime

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

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

fn lt(&self, __arg_0: &NaiveDateTime) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, __arg_0: &NaiveDateTime) -> bool

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

fn gt(&self, __arg_0: &NaiveDateTime) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, __arg_0: &NaiveDateTime) -> bool

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

impl Ord for NaiveDateTime

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

This method returns an Ordering between self and other.

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

🔬 This is a nightly-only experimental API. (ord_max_min)

Compares and returns the maximum of two values.

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

🔬 This is a nightly-only experimental API. (ord_max_min)

Compares and returns the minimum of two values.

impl Copy for NaiveDateTime

impl Clone for NaiveDateTime

fn clone(&self) -> NaiveDateTime

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Datelike for NaiveDateTime

fn year(&self) -> i32

Returns the year number in the calendar date.

See also the NaiveDate::year method.

Example

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

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

fn month(&self) -> u32

Returns the month number starting from 1.

The return value ranges from 1 to 12.

See also the NaiveDate::month method.

Example

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

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

fn month0(&self) -> u32

Returns the month number starting from 0.

The return value ranges from 0 to 11.

See also the NaiveDate::month0 method.

Example

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

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

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.)

See also the NaiveDate::day method.

Example

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

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

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.)

See also the NaiveDate::day0 method.

Example

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

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

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.)

See also the NaiveDate::ordinal method.

Example

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

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

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.)

See also the NaiveDate::ordinal0 method.

Example

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

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

fn weekday(&self) -> Weekday

Returns the day of week.

See also the NaiveDate::weekday method.

Example

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

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

fn isoweekdate(&self) -> (i32, u32, Weekday)

Returns the ISO week date: an adjusted year, week number and day of week. The adjusted year may differ from that of the calendar date.

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

Makes a new NaiveDateTime with the year number changed.

Returns None when the resulting NaiveDateTime would be invalid.

See also the NaiveDate::with_year method.

Example

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

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

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

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

Returns None when the resulting NaiveDateTime would be invalid.

See also the NaiveDate::with_month method.

Example

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

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

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

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

Returns None when the resulting NaiveDateTime would be invalid.

See also the NaiveDate::with_month0 method.

Example

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

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

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

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

Returns None when the resulting NaiveDateTime would be invalid.

See also the NaiveDate::with_day method.

Example

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

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

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

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

Returns None when the resulting NaiveDateTime would be invalid.

See also the NaiveDate::with_day0 method.

Example

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

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

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

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

Returns None when the resulting NaiveDateTime would be invalid.

See also the NaiveDate::with_ordinal method.

Example

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

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

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

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

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

Returns None when the resulting NaiveDateTime would be invalid.

See also the NaiveDate::with_ordinal0 method.

Example

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

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

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

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

Returns the number of days since January 1, 1 (Day 1) in the proleptic Gregorian calendar.

impl Timelike for NaiveDateTime

fn hour(&self) -> u32

Returns the hour number from 0 to 23.

See also the NaiveTime::hour method.

Example

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

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

fn minute(&self) -> u32

Returns the minute number from 0 to 59.

See also the NaiveTime::minute method.

Example

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

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

fn second(&self) -> u32

Returns the second number from 0 to 59.

See also the NaiveTime::second method.

Example

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

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

fn nanosecond(&self) -> u32

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

See also the NaiveTime::nanosecond method.

Example

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

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

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

Makes a new NaiveDateTime with the hour number changed.

Returns None when the resulting NaiveDateTime would be invalid.

See also the NaiveTime::with_hour method.

Example

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

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

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

Makes a new NaiveDateTime with the minute number changed.

Returns None when the resulting NaiveDateTime would be invalid.

See also the NaiveTime::with_minute method.

Example

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

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

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

Makes a new NaiveDateTime with the second number changed.

Returns None when the resulting NaiveDateTime would be invalid. As with the second method, the input range is restricted to 0 through 59.

See also the NaiveTime::with_second method.

Example

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

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

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

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

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

See also the NaiveTime::with_nanosecond method.

Example

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

let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
assert_eq!(dt.with_nanosecond(333_333_333),
           Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_nano(12, 34, 56, 333_333_333)));
assert_eq!(dt.with_nanosecond(1_333_333_333), // leap second
           Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_nano(12, 34, 56, 1_333_333_333)));
assert_eq!(dt.with_nanosecond(2_000_000_000), None);

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

Returns the hour number from 1 to 12 with a boolean flag, which is false for AM and true for PM.

fn num_seconds_from_midnight(&self) -> u32

Returns the number of non-leap seconds past the last midnight.

impl Hash for NaiveDateTime

NaiveDateTime can be used as a key to the hash maps (in principle).

Practically this also takes account of fractional seconds, so it is not recommended. (For the obvious reason this also distinguishes leap seconds from non-leap seconds.)

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, 

Feeds a slice of this type into the given [Hasher].

impl Add<Duration> for NaiveDateTime

type Output = NaiveDateTime

The resulting type after applying the + operator

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

The method for the + operator

impl Sub<NaiveDateTime> for NaiveDateTime

type Output = Duration

The resulting type after applying the - operator

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

The method for the - operator

impl Sub<Duration> for NaiveDateTime

type Output = NaiveDateTime

The resulting type after applying the - operator

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

The method for the - operator

impl Debug for NaiveDateTime

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

Formats the value using the given formatter.

impl Display for NaiveDateTime

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

Formats the value using the given formatter.

impl FromStr for NaiveDateTime

type Err = ParseError

The associated error which can be returned from parsing.

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

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