Struct Local

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

Trait Implementations

impl Clone for Local

fn clone(&self) -> Self

impl Copy for Local

impl Debug for Local

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

impl TimeZone for Local

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

Auto Trait Implementations

impl Freeze for Local

impl RefUnwindSafe for Local

impl Send for Local

impl Sync for Local

impl Unpin for Local

impl UnsafeUnpin for Local

impl UnwindSafe for Local

Blanket Implementations

impl<T> Any for Local where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Local where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Local where T: ?Sized,

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

impl<T> CloneToUninit for Local where T: Clone,

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

impl<T> From<T> for Local

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for Local where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T, U> Into<U> for Local where U: From<T>,

fn into(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<U> for Local where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for Local where U: TryFrom<T>,

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