Struct `Local`

struct Local

The local timescale.

Using the TimeZone methods on the Local struct is the preferred way to construct DateTime<Local> instances.

Example

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

let dt1: DateTime<Local> = Local::now();
let dt2: DateTime<Local> = Local.timestamp_opt(0, 0).unwrap();
assert!(dt1 >= dt2);

Implementations

`impl Local`

fn today() -> Date<Local>

Returns a Date which corresponds to the current date.

fn now() -> DateTime<Local>

Returns a DateTime<Local> which corresponds to the current date, time and offset from UTC.

See also the similar [Utc::now()] which returns DateTime<Utc>, i.e. without the local offset.

Example

# #![allow(unused_variables)]
# use chrono::{DateTime, FixedOffset, Local};
// Current local time
let now = Local::now();

// Current local date
let today = now.date_naive();

// Current local time, converted to `DateTime<FixedOffset>`
let now_fixed_offset = Local::now().fixed_offset();
// or
let now_fixed_offset: DateTime<FixedOffset> = Local::now().into();

// Current time in some timezone (let's use +05:00)
// Note that it is usually more efficient to use `Utc::now` for this use case.
let offset = FixedOffset::east_opt(5 * 60 * 60).unwrap();
let now_with_offset = Local::now().with_timezone(&offset);

`impl Clone for Local`

fn clone(self: &Self) -> Local

`impl Copy for Local`

`impl Debug for Local`

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

`impl Freeze for Local`

`impl RefUnwindSafe for Local`

`impl Send for Local`

`impl Sync for Local`

`impl TimeZone for Local`

fn from_offset(_offset: &FixedOffset) -> Local
fn offset_from_local_date(self: &Self, local: &NaiveDate) -> MappedLocalTime<FixedOffset>
fn offset_from_local_datetime(self: &Self, local: &NaiveDateTime) -> MappedLocalTime<FixedOffset>
fn offset_from_utc_date(self: &Self, utc: &NaiveDate) -> FixedOffset
fn offset_from_utc_datetime(self: &Self, utc: &NaiveDateTime) -> FixedOffset

`impl Unpin for Local`

`impl UnsafeUnpin for Local`

`impl UnwindSafe for Local`

`impl<T> Any for Local`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Local`

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

`impl<T> BorrowMut for Local`

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

`impl<T> CloneToUninit for Local`

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

`impl<T> From for Local`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for Local`

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

`impl<T, U> Into for Local`

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 Local`

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

`impl<T, U> TryInto for Local`

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