Struct DateTime

struct DateTime<Tz: TimeZone> { ... }

ISO 8601 combined date and time with time zone.

There are some constructors implemented here (the from_* methods), but the general-purpose constructors are all via the methods on the TimeZone implementations.

Implementations

impl DateTime<FixedOffset>

fn parse_from_rfc2822(s: &str) -> ParseResult<DateTime<FixedOffset>>

Parses an RFC 2822 date-and-time string into a DateTime<FixedOffset> value.

This parses valid RFC 2822 datetime strings (such as Tue, 1 Jul 2003 10:52:37 +0200) and returns a new DateTime instance with the parsed timezone as the FixedOffset.

RFC 2822 is the internet message standard that specifies the representation of times in HTTP and email headers. It is the 2001 revision of RFC 822, and is itself revised as RFC 5322 in 2008.

Support for the obsolete date format

  • A 2-digit year is interpreted to be a year in 1950-2049.
  • The standard allows comments and whitespace between many of the tokens. See 4.3 and Appendix A.5
  • Single letter 'military' time zone names are parsed as a -0000 offset. They were defined with the wrong sign in RFC 822 and corrected in RFC 2822. But because the meaning is now ambiguous, the standard says they should be be considered as -0000 unless there is out-of-band information confirming their meaning. The exception is Z, which remains identical to +0000.

Example

# use chrono::{DateTime, FixedOffset, TimeZone};
assert_eq!(
    DateTime::parse_from_rfc2822("Wed, 18 Feb 2015 23:16:09 GMT").unwrap(),
    FixedOffset::east_opt(0).unwrap().with_ymd_and_hms(2015, 2, 18, 23, 16, 9).unwrap()
);

fn parse_from_rfc3339(s: &str) -> ParseResult<DateTime<FixedOffset>>

Parses an RFC 3339 date-and-time string into a DateTime<FixedOffset> value.

Parses all valid RFC 3339 values (as well as the subset of valid ISO 8601 values that are also valid RFC 3339 date-and-time values) and returns a new DateTime with a FixedOffset corresponding to the parsed timezone. While RFC 3339 values come in a wide variety of shapes and sizes, 1996-12-19T16:39:57-08:00 is an example of the most commonly encountered variety of RFC 3339 formats.

Why isn't this named parse_from_iso8601? That's because ISO 8601 allows representing values in a wide range of formats, only some of which represent actual date-and-time instances (rather than periods, ranges, dates, or times). Some valid ISO 8601 values are also simultaneously valid RFC 3339 values, but not all RFC 3339 values are valid ISO 8601 values (or the other way around).

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

Parses a string from a user-specified format into a DateTime<FixedOffset> value.

Note that this method requires a timezone in the input string. See NaiveDateTime::parse_from_str for a version that does not require a timezone in the to-be-parsed str. The returned DateTime value will have a FixedOffset reflecting the parsed timezone.

See the format::strftime module for supported format sequences.

Example

use chrono::{DateTime, FixedOffset, NaiveDate, TimeZone};

let dt = DateTime::parse_from_str("1983 Apr 13 12:09:14.274 +0000", "%Y %b %d %H:%M:%S%.3f %z");
assert_eq!(
    dt,
    Ok(FixedOffset::east_opt(0)
        .unwrap()
        .from_local_datetime(
            &NaiveDate::from_ymd_opt(1983, 4, 13)
                .unwrap()
                .and_hms_milli_opt(12, 9, 14, 274)
                .unwrap()
        )
        .unwrap())
);

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

Parses a string from a user-specified format into a DateTime<FixedOffset> value, and a slice with the remaining portion of the string.

Note that this method requires a timezone in the input string. See NaiveDateTime::parse_and_remainder for a version that does not require a timezone in s. The returned DateTime value will have a FixedOffset reflecting the parsed timezone.

See the format::strftime module for supported format sequences.

Similar to parse_from_str.

Example

# use chrono::{DateTime, FixedOffset, TimeZone};
let (datetime, remainder) = DateTime::parse_and_remainder(
    "2015-02-18 23:16:09 +0200 trailing text",
    "%Y-%m-%d %H:%M:%S %z",
)
.unwrap();
assert_eq!(
    datetime,
    FixedOffset::east_opt(2 * 3600).unwrap().with_ymd_and_hms(2015, 2, 18, 23, 16, 9).unwrap()
);
assert_eq!(remainder, " trailing text");

impl DateTime<Utc>

const fn from_timestamp(secs: i64, nsecs: u32) -> Option<Self>

Makes a new DateTime<Utc> from the number of non-leap seconds since January 1, 1970 0:00:00 UTC (aka "UNIX timestamp") and the number of nanoseconds since the last whole non-leap second.

This is guaranteed to round-trip with regard to timestamp and timestamp_subsec_nanos.

If you need to create a DateTime with a TimeZone different from Utc, use TimeZone::timestamp_opt or DateTime::with_timezone.

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

Errors

Returns None on out-of-range number of seconds and/or invalid nanosecond, otherwise returns Some(DateTime {...}).

Example

use chrono::DateTime;

let dt = DateTime::from_timestamp(1431648000, 0).expect("invalid timestamp");

assert_eq!(dt.to_string(), "2015-05-15 00:00:00 UTC");
assert_eq!(DateTime::from_timestamp(dt.timestamp(), dt.timestamp_subsec_nanos()).unwrap(), dt);

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

Makes a new DateTime<Utc> from the number of non-leap milliseconds since January 1, 1970 0:00:00.000 UTC (aka "UNIX timestamp").

This is guaranteed to round-trip with timestamp_millis.

If you need to create a DateTime with a TimeZone different from Utc, use TimeZone::timestamp_millis_opt or DateTime::with_timezone.

Errors

Returns None on out-of-range number of milliseconds, otherwise returns Some(DateTime {...}).

Example

use chrono::DateTime;

let dt = DateTime::from_timestamp_millis(947638923004).expect("invalid timestamp");

assert_eq!(dt.to_string(), "2000-01-12 01:02:03.004 UTC");
assert_eq!(DateTime::from_timestamp_millis(dt.timestamp_millis()).unwrap(), dt);

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

Creates a new DateTime<Utc> from the number of non-leap microseconds since January 1, 1970 0:00:00.000 UTC (aka "UNIX timestamp").

This is guaranteed to round-trip with timestamp_micros.

If you need to create a DateTime with a TimeZone different from Utc, use TimeZone::timestamp_micros or DateTime::with_timezone.

Errors

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

Example

use chrono::DateTime;

let timestamp_micros: i64 = 1662921288000000; // Sun, 11 Sep 2022 18:34:48 UTC
let dt = DateTime::from_timestamp_micros(timestamp_micros);
assert!(dt.is_some());
assert_eq!(timestamp_micros, dt.expect("invalid timestamp").timestamp_micros());

// Negative timestamps (before the UNIX epoch) are supported as well.
let timestamp_micros: i64 = -2208936075000000; // Mon, 1 Jan 1900 14:38:45 UTC
let dt = DateTime::from_timestamp_micros(timestamp_micros);
assert!(dt.is_some());
assert_eq!(timestamp_micros, dt.expect("invalid timestamp").timestamp_micros());

const fn from_timestamp_nanos(nanos: i64) -> Self

Creates a new [DateTime<Utc>] from the number of non-leap nanoseconds since January 1, 1970 0:00:00.000 UTC (aka "UNIX timestamp").

This is guaranteed to round-trip with timestamp_nanos.

If you need to create a DateTime with a TimeZone different from Utc, use TimeZone::timestamp_nanos or DateTime::with_timezone.

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

An i64 with nanosecond precision can span a range of ~584 years. Because all values can be represented as a DateTime this method never fails.

Example

use chrono::DateTime;

let timestamp_nanos: i64 = 1662921288_000_000_000; // Sun, 11 Sep 2022 18:34:48 UTC
let dt = DateTime::from_timestamp_nanos(timestamp_nanos);
assert_eq!(timestamp_nanos, dt.timestamp_nanos_opt().unwrap());

// Negative timestamps (before the UNIX epoch) are supported as well.
let timestamp_nanos: i64 = -2208936075_000_000_000; // Mon, 1 Jan 1900 14:38:45 UTC
let dt = DateTime::from_timestamp_nanos(timestamp_nanos);
assert_eq!(timestamp_nanos, dt.timestamp_nanos_opt().unwrap());

impl<Tz: TimeZone> DateTime<Tz>

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

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

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

Formats the combined date and time per the specified format string.

See the crate::format::strftime module for the supported escape sequences.

Example

use chrono::prelude::*;

let date_time: DateTime<Utc> = Utc.with_ymd_and_hms(2017, 04, 02, 12, 50, 32).unwrap();
let formatted = format!("{}", date_time.format("%d/%m/%Y %H:%M"));
assert_eq!(formatted, "02/04/2017 12:50");

impl<Tz: TimeZone> DateTime<Tz>

const fn from_naive_utc_and_offset(datetime: NaiveDateTime, offset: <Tz as >::Offset) -> DateTime<Tz>

Makes a new DateTime from its components: a NaiveDateTime in UTC and an Offset.

This is a low-level method, intended for use cases such as deserializing a DateTime or passing it through FFI.

For regular use you will probably want to use a method such as TimeZone::from_local_datetime or NaiveDateTime::and_local_timezone instead.

Example

# #[cfg(feature = "clock")] {
use chrono::{DateTime, Local};

let dt = Local::now();
// Get components
let naive_utc = dt.naive_utc();
let offset = dt.offset().clone();
// Serialize, pass through FFI... and recreate the `DateTime`:
let dt_new = DateTime::<Local>::from_naive_utc_and_offset(naive_utc, offset);
assert_eq!(dt, dt_new);
# }

fn from_utc(datetime: NaiveDateTime, offset: <Tz as >::Offset) -> DateTime<Tz>

Makes a new DateTime from its components: a NaiveDateTime in UTC and an Offset.

fn from_local(datetime: NaiveDateTime, offset: <Tz as >::Offset) -> DateTime<Tz>

Makes a new DateTime from a NaiveDateTime in local time and an Offset.

Panics

Panics if the local datetime can't be converted to UTC because it would be out of range.

This can happen if datetime is near the end of the representable range of NaiveDateTime, and the offset from UTC pushes it beyond that.

fn date(self: &Self) -> Date<Tz>

Retrieves the date component with an associated timezone.

Unless you are immediately planning on turning this into a DateTime with the same timezone you should use the date_naive method.

NaiveDate is a more well-defined type, and has more traits implemented on it, so should be preferred to Date any time you truly want to operate on dates.

Panics

DateTime internally stores the date and time in UTC with a NaiveDateTime. This method will panic if the offset from UTC would push the local date outside of the representable range of a Date.

fn date_naive(self: &Self) -> NaiveDate

Retrieves the date component.

Panics

DateTime internally stores the date and time in UTC with a NaiveDateTime. This method will panic if the offset from UTC would push the local date outside of the representable range of a NaiveDate.

Example

use chrono::prelude::*;

let date: DateTime<Utc> = Utc.with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap();
let other: DateTime<FixedOffset> =
    FixedOffset::east_opt(23).unwrap().with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap();
assert_eq!(date.date_naive(), other.date_naive());

fn time(self: &Self) -> NaiveTime

Retrieves the time component.

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

Returns the number of non-leap seconds since January 1, 1970 0:00:00 UTC (aka "UNIX timestamp").

The reverse operation of creating a DateTime from a timestamp can be performed using from_timestamp or TimeZone::timestamp_opt.

use chrono::{DateTime, TimeZone, Utc};

let dt: DateTime<Utc> = Utc.with_ymd_and_hms(2015, 5, 15, 0, 0, 0).unwrap();
assert_eq!(dt.timestamp(), 1431648000);

assert_eq!(DateTime::from_timestamp(dt.timestamp(), dt.timestamp_subsec_nanos()).unwrap(), dt);

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

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

Example

use chrono::{NaiveDate, Utc};

let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
    .unwrap()
    .and_hms_milli_opt(0, 0, 1, 444)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_millis(), 1_444);

let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
    .unwrap()
    .and_hms_milli_opt(1, 46, 40, 555)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_millis(), 1_000_000_000_555);

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

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

Example

use chrono::{NaiveDate, Utc};

let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
    .unwrap()
    .and_hms_micro_opt(0, 0, 1, 444)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_micros(), 1_000_444);

let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
    .unwrap()
    .and_hms_micro_opt(1, 46, 40, 555)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_micros(), 1_000_000_000_000_555);

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

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

Panics

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

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

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

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

Errors

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

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

Example

use chrono::{NaiveDate, Utc};

let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
    .unwrap()
    .and_hms_nano_opt(0, 0, 1, 444)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), Some(1_000_000_444));

let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
    .unwrap()
    .and_hms_nano_opt(1, 46, 40, 555)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), Some(1_000_000_000_000_000_555));

let dt = NaiveDate::from_ymd_opt(1677, 9, 21)
    .unwrap()
    .and_hms_nano_opt(0, 12, 43, 145_224_192)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), Some(-9_223_372_036_854_775_808));

let dt = NaiveDate::from_ymd_opt(2262, 4, 11)
    .unwrap()
    .and_hms_nano_opt(23, 47, 16, 854_775_807)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), Some(9_223_372_036_854_775_807));

let dt = NaiveDate::from_ymd_opt(1677, 9, 21)
    .unwrap()
    .and_hms_nano_opt(0, 12, 43, 145_224_191)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), None);

let dt = NaiveDate::from_ymd_opt(2262, 4, 11)
    .unwrap()
    .and_hms_nano_opt(23, 47, 16, 854_775_808)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), None);

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

Returns the number of milliseconds since the last second boundary.

In event of a leap second this may exceed 999.

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

Returns the number of microseconds since the last second boundary.

In event of a leap second this may exceed 999,999.

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

Returns the number of nanoseconds since the last second boundary

In event of a leap second this may exceed 999,999,999.

const fn offset(self: &Self) -> &<Tz as >::Offset

Retrieves an associated offset from UTC.

fn timezone(self: &Self) -> Tz

Retrieves an associated time zone.

fn with_timezone<Tz2: TimeZone>(self: &Self, tz: &Tz2) -> DateTime<Tz2>

Changes the associated time zone. The returned DateTime references the same instant of time from the perspective of the provided time zone.

fn fixed_offset(self: &Self) -> DateTime<FixedOffset>

Fix the offset from UTC to its current value, dropping the associated timezone information. This it useful for converting a generic DateTime<Tz: Timezone> to DateTime<FixedOffset>.

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

Turn this DateTime into a DateTime<Utc>, dropping the offset and associated timezone information.

fn checked_add_signed(self: Self, rhs: TimeDelta) -> Option<DateTime<Tz>>

Adds given TimeDelta to the current date and time.

Errors

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

fn checked_add_months(self: Self, months: Months) -> Option<DateTime<Tz>>

Adds given Months to the current date and time.

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

See NaiveDate::checked_add_months for more details on behavior.

Errors

Returns None if:

  • The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
  • The resulting UTC datetime would be out of range.
  • The resulting local datetime would be out of range (unless months is zero).
fn checked_sub_signed(self: Self, rhs: TimeDelta) -> Option<DateTime<Tz>>

Subtracts given TimeDelta from the current date and time.

Errors

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

fn checked_sub_months(self: Self, months: Months) -> Option<DateTime<Tz>>

Subtracts given Months from the current date and time.

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

See NaiveDate::checked_sub_months for more details on behavior.

Errors

Returns None if:

  • The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
  • The resulting UTC datetime would be out of range.
  • The resulting local datetime would be out of range (unless months is zero).
fn checked_add_days(self: Self, days: Days) -> Option<Self>

Add a duration in Days to the date part of the DateTime.

Errors

Returns None if:

  • The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
  • The resulting UTC datetime would be out of range.
  • The resulting local datetime would be out of range (unless days is zero).
fn checked_sub_days(self: Self, days: Days) -> Option<Self>

Subtract a duration in Days from the date part of the DateTime.

Errors

Returns None if:

  • The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
  • The resulting UTC datetime would be out of range.
  • The resulting local datetime would be out of range (unless days is zero).
fn signed_duration_since<Tz2: TimeZone, impl Borrow<DateTime<Tz2>>: Borrow<DateTime<Tz2>>>(self: Self, rhs: impl Borrow<DateTime<Tz2>>) -> TimeDelta

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

const fn naive_utc(self: &Self) -> NaiveDateTime

Returns a view to the naive UTC datetime.

fn naive_local(self: &Self) -> NaiveDateTime

Returns a view to the naive local datetime.

Panics

DateTime internally stores the date and time in UTC with a NaiveDateTime. This method will panic if the offset from UTC would push the local datetime outside of the representable range of a NaiveDateTime.

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

Retrieve the elapsed years from now to the given DateTime.

Errors

Returns None if base > self.

fn to_rfc2822(self: &Self) -> String

Returns an RFC 2822 date and time string such as Tue, 1 Jul 2003 10:52:37 +0200.

Panics

Panics if the date can not be represented in this format: the year may not be negative and can not have more than 4 digits.

fn to_rfc3339(self: &Self) -> String

Returns an RFC 3339 and ISO 8601 date and time string such as 1996-12-19T16:39:57-08:00.

fn to_rfc3339_opts(self: &Self, secform: SecondsFormat, use_z: bool) -> String

Return an RFC 3339 and ISO 8601 date and time string with subseconds formatted as per SecondsFormat.

If use_z is true and the timezone is UTC (offset 0), uses Z as per Fixed::TimezoneOffsetColonZ. If use_z is false, uses Fixed::TimezoneOffsetColon

Examples

# use chrono::{FixedOffset, SecondsFormat, TimeZone, NaiveDate};
let dt = NaiveDate::from_ymd_opt(2018, 1, 26)
    .unwrap()
    .and_hms_micro_opt(18, 30, 9, 453_829)
    .unwrap()
    .and_utc();
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Millis, false), "2018-01-26T18:30:09.453+00:00");
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Millis, true), "2018-01-26T18:30:09.453Z");
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Secs, true), "2018-01-26T18:30:09Z");

let pst = FixedOffset::east_opt(8 * 60 * 60).unwrap();
let dt = pst
    .from_local_datetime(
        &NaiveDate::from_ymd_opt(2018, 1, 26)
            .unwrap()
            .and_hms_micro_opt(10, 30, 9, 453_829)
            .unwrap(),
    )
    .unwrap();
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Secs, true), "2018-01-26T10:30:09+08:00");

fn with_time(self: &Self, time: NaiveTime) -> LocalResult<Self>

Set the time to a new fixed time on the existing date.

Errors

Returns LocalResult::None if the datetime is at the edge of the representable range for a DateTime, and with_time would push the value in UTC out of range.

Example

# #[cfg(feature = "clock")] {
use chrono::{Local, NaiveTime};

let noon = NaiveTime::from_hms_opt(12, 0, 0).unwrap();
let today_noon = Local::now().with_time(noon);
let today_midnight = Local::now().with_time(NaiveTime::MIN);

assert_eq!(today_noon.single().unwrap().time(), noon);
assert_eq!(today_midnight.single().unwrap().time(), NaiveTime::MIN);
# }

impl Default for DateTime<FixedOffset>

fn default() -> Self

impl Default for DateTime<Local>

fn default() -> Self

impl Default for DateTime<Utc>

fn default() -> Self

impl From for DateTime<FixedOffset>

fn from(src: DateTime<Utc>) -> Self

Convert this DateTime<Utc> instance into a DateTime<FixedOffset> instance.

Conversion is done via DateTime::with_timezone. Note that the converted value returned by this will be created with a fixed timezone offset of 0.

impl From for DateTime<FixedOffset>

fn from(src: DateTime<Local>) -> Self

Convert this DateTime<Local> instance into a DateTime<FixedOffset> instance.

Conversion is performed via DateTime::with_timezone.

impl From for DateTime<Local>

fn from(src: DateTime<Utc>) -> Self

Convert this DateTime<Utc> instance into a DateTime<Local> instance.

Conversion is performed via DateTime::with_timezone, accounting for the difference in timezones.

impl From for DateTime<Local>

fn from(t: SystemTime) -> DateTime<Local>

impl From for DateTime<Local>

fn from(src: DateTime<FixedOffset>) -> Self

Convert this DateTime<FixedOffset> instance into a DateTime<Local> instance.

Conversion is performed via DateTime::with_timezone. Returns the equivalent value in local time.

impl From for DateTime<Utc>

fn from(src: DateTime<Local>) -> Self

Convert this DateTime<Local> instance into a DateTime<Utc> instance.

Conversion is performed via DateTime::with_timezone, accounting for the difference in timezones.

impl From for DateTime<Utc>

fn from(src: DateTime<FixedOffset>) -> Self

Convert this DateTime<FixedOffset> instance into a DateTime<Utc> instance.

Conversion is performed via DateTime::with_timezone, accounting for the timezone difference.

impl From for DateTime<Utc>

fn from(t: SystemTime) -> DateTime<Utc>

impl FromStr for DateTime<FixedOffset>

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

impl FromStr for DateTime<Local>

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

impl FromStr for DateTime<Utc>

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

impl<T> Any for DateTime<Tz>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for DateTime<Tz>

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

impl<T> BorrowMut for DateTime<Tz>

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

impl<T> CloneToUninit for DateTime<Tz>

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

impl<T> From for DateTime<Tz>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> SubsecRound for DateTime<Tz>

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

impl<T> ToOwned for DateTime<Tz>

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

impl<T> ToString for DateTime<Tz>

fn to_string(self: &Self) -> String

impl<T, U> Into for DateTime<Tz>

fn into(self: Self) -> U

Calls U::from(self).

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

impl<T, U> TryFrom for DateTime<Tz>

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

impl<T, U> TryInto for DateTime<Tz>

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

impl<Tz> Freeze for DateTime<Tz>

impl<Tz> RefUnwindSafe for DateTime<Tz>

impl<Tz> Send for DateTime<Tz>

impl<Tz> Sync for DateTime<Tz>

impl<Tz> Unpin for DateTime<Tz>

impl<Tz> UnsafeUnpin for DateTime<Tz>

impl<Tz> UnwindSafe for DateTime<Tz>

impl<Tz: $crate::clone::Clone + TimeZone> Clone for DateTime<Tz>

fn clone(self: &Self) -> DateTime<Tz>

impl<Tz: TimeZone> Add for DateTime<Tz>

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

impl<Tz: TimeZone> Add for DateTime<Tz>

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

impl<Tz: TimeZone> Add for DateTime<Tz>

fn add(self: Self, rhs: Duration) -> DateTime<Tz>

impl<Tz: TimeZone> Add for DateTime<Tz>

fn add(self: Self, rhs: FixedOffset) -> DateTime<Tz>

impl<Tz: TimeZone> Add for DateTime<Tz>

fn add(self: Self, rhs: TimeDelta) -> DateTime<Tz>

impl<Tz: TimeZone> AddAssign for DateTime<Tz>

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

impl<Tz: TimeZone> AddAssign for DateTime<Tz>

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

impl<Tz: TimeZone> Copy for DateTime<Tz>

impl<Tz: TimeZone> Datelike for DateTime<Tz>

fn year(self: &Self) -> i32
fn month(self: &Self) -> u32
fn month0(self: &Self) -> u32
fn day(self: &Self) -> u32
fn day0(self: &Self) -> u32
fn ordinal(self: &Self) -> u32
fn ordinal0(self: &Self) -> u32
fn weekday(self: &Self) -> Weekday
fn iso_week(self: &Self) -> IsoWeek
fn with_year(self: &Self, year: i32) -> Option<DateTime<Tz>>

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

See also the NaiveDate::with_year method.

Errors

Returns None if:

  • The resulting date does not exist (February 29 in a non-leap year).
  • The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
  • The resulting UTC datetime would be out of range.
  • The resulting local datetime would be out of range (unless the year remains the same).
fn with_month(self: &Self, month: u32) -> Option<DateTime<Tz>>

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

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

See also the NaiveDate::with_month method.

Errors

Returns None if:

  • The resulting date does not exist (for example month(4) when day of the month is 31).
  • The value for month is invalid.
  • The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
fn with_month0(self: &Self, month0: u32) -> Option<DateTime<Tz>>

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

See also the NaiveDate::with_month0 method.

Errors

Returns None if:

  • The resulting date does not exist (for example month0(3) when day of the month is 31).
  • The value for month0 is invalid.
  • The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
fn with_day(self: &Self, day: u32) -> Option<DateTime<Tz>>

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

See also the NaiveDate::with_day method.

Errors

Returns None if:

  • The resulting date does not exist (for example day(31) in April).
  • The value for day is invalid.
  • The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
fn with_day0(self: &Self, day0: u32) -> Option<DateTime<Tz>>

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

See also the NaiveDate::with_day0 method.

Errors

Returns None if:

  • The resulting date does not exist (for example day(30) in April).
  • The value for day0 is invalid.
  • The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
fn with_ordinal(self: &Self, ordinal: u32) -> Option<DateTime<Tz>>

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

See also the NaiveDate::with_ordinal method.

Errors

Returns None if:

  • The resulting date does not exist (with_ordinal(366) in a non-leap year).
  • The value for ordinal is invalid.
  • The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
fn with_ordinal0(self: &Self, ordinal0: u32) -> Option<DateTime<Tz>>

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

See also the NaiveDate::with_ordinal0 method.

Errors

Returns None if:

  • The resulting date does not exist (with_ordinal0(365) in a non-leap year).
  • The value for ordinal0 is invalid.
  • The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.

impl<Tz: TimeZone> Debug for DateTime<Tz>

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

impl<Tz: TimeZone> Display for DateTime<Tz>

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

impl<Tz: TimeZone> DurationRound for DateTime<Tz>

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

impl<Tz: TimeZone> Eq for DateTime<Tz>

impl<Tz: TimeZone> Hash for DateTime<Tz>

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

impl<Tz: TimeZone> Ord for DateTime<Tz>

fn cmp(self: &Self, other: &DateTime<Tz>) -> Ordering

impl<Tz: TimeZone> Sub for DateTime<Tz>

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

impl<Tz: TimeZone> Sub for DateTime<Tz>

fn sub(self: Self, rhs: &DateTime<Tz>) -> TimeDelta

impl<Tz: TimeZone> Sub for DateTime<Tz>

fn sub(self: Self, rhs: Duration) -> DateTime<Tz>

impl<Tz: TimeZone> Sub for DateTime<Tz>

fn sub(self: Self, rhs: TimeDelta) -> DateTime<Tz>

impl<Tz: TimeZone> Sub for DateTime<Tz>

fn sub(self: Self, rhs: FixedOffset) -> DateTime<Tz>

impl<Tz: TimeZone> Sub for DateTime<Tz>

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

impl<Tz: TimeZone> Sub for DateTime<Tz>

fn sub(self: Self, rhs: DateTime<Tz>) -> TimeDelta

impl<Tz: TimeZone> SubAssign for DateTime<Tz>

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

impl<Tz: TimeZone> SubAssign for DateTime<Tz>

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

impl<Tz: TimeZone> Timelike for DateTime<Tz>

fn hour(self: &Self) -> u32
fn minute(self: &Self) -> u32
fn second(self: &Self) -> u32
fn nanosecond(self: &Self) -> u32
fn with_hour(self: &Self, hour: u32) -> Option<DateTime<Tz>>

Makes a new DateTime with the hour number changed.

See also the NaiveTime::with_hour method.

Errors

Returns None if:

  • The value for hour is invalid.
  • The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
fn with_minute(self: &Self, min: u32) -> Option<DateTime<Tz>>

Makes a new DateTime with the minute number changed.

See also the NaiveTime::with_minute method.

Errors

  • The value for minute is invalid.
  • The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
fn with_second(self: &Self, sec: u32) -> Option<DateTime<Tz>>

Makes a new DateTime with the second number changed.

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

See also the NaiveTime::with_second method.

Errors

Returns None if:

  • The value for second is invalid.
  • The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
fn with_nanosecond(self: &Self, nano: u32) -> Option<DateTime<Tz>>

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

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

See also the NaiveTime::with_nanosecond method.

Errors

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

impl<Tz: TimeZone, Tz2: TimeZone> PartialEq for DateTime<Tz>

fn eq(self: &Self, other: &DateTime<Tz2>) -> bool

impl<Tz: TimeZone, Tz2: TimeZone> PartialOrd for DateTime<Tz>

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

Compare two DateTimes based on their true time, ignoring time zones

Example

use chrono::prelude::*;

let earlier = Utc
    .with_ymd_and_hms(2015, 5, 15, 2, 0, 0)
    .unwrap()
    .with_timezone(&FixedOffset::west_opt(1 * 3600).unwrap());
let later = Utc
    .with_ymd_and_hms(2015, 5, 15, 3, 0, 0)
    .unwrap()
    .with_timezone(&FixedOffset::west_opt(5 * 3600).unwrap());

assert_eq!(earlier.to_string(), "2015-05-15 01:00:00 -01:00");
assert_eq!(later.to_string(), "2015-05-14 22:00:00 -05:00");

assert!(later > earlier);