Elixir 1.7

DateTime




elixir

DateTime

समय क्षेत्र के साथ एक डेटाइम कार्यान्वयन।

यह डेटाटाइम एक निश्चित समय क्षेत्र में डेटाइम के एक अल्पकालिक स्नैपशॉट के रूप में देखा जा सकता है। इस तरह के उद्देश्यों के लिए, इसमें UTC और मानक दोनों ऑफ़सेट शामिल हैं, साथ ही ज़ोन का संक्षिप्त नाम फ़ील्ड विशेष रूप से फ़ॉर्मेटिंग उद्देश्यों के लिए उपयोग किया जाता है।

याद रखें, Elixir में ==/2 , >/2 , </2 और मित्रों का उपयोग संरचनात्मक है और डेटाइम टाइम फील्ड पर आधारित है। डेटाटाइम के बीच उचित तुलना के लिए, compare/2 फ़ंक्शन का उपयोग compare/2

इस मॉड्यूल पर कार्य DateTime संरचना के साथ-साथ किसी भी संरचना के साथ कार्य करते हैं जिसमें DateTime संरचना के समान फ़ील्ड होते हैं। ऐसे कार्य Calendar.datetime/0 टाइपटाइम Calendar.datetime/0 को उनके टाइपस्पेस ( t/0 बजाय) से उम्मीद करते हैं।

डेवलपर्स को सीधे DateTime संरचना बनाने से बचना चाहिए और इसके बजाय इस मॉड्यूल द्वारा प्रदान किए गए कार्यों पर भरोसा करना चाहिए और साथ ही तीसरे पक्ष के कैलेंडर पुस्तकालयों में भी।

मेरे कार्य कहां हैं?

आप इस मॉड्यूल को केवल रूपांतरण कार्यों के साथ-साथ यूटीसी पर काम करने वाले कार्यों को देखेंगे। ऐसा इसलिए है क्योंकि एक उचित DateTime कार्यान्वयन के लिए एक समय क्षेत्र डेटाबेस की आवश्यकता होती है जो वर्तमान में अमृत के भाग के रूप में प्रदान नहीं किया गया है।

इसे आगामी संस्करणों में संबोधित किया जा सकता है, इस बीच, समय क्षेत्र समर्थन के साथ DateTime बिल्डिंग और समान कार्यक्षमता प्रदान करने के लिए 3 पार्टी पैकेज का उपयोग करें।

सारांश

प्रकार

t/0

कार्य

compare/2

दो डेटाटाइम संरचना की तुलना करता है

रूपांतरित करें (डेटाइम, कैलेंडर)

दिए गए datetime को एक कैलेंडर से दूसरे कैलेंडर में परिवर्तित करता है

कन्वर्ट (डेटाटाइम, कैलेंडर)

दिए गए datetime को एक कैलेंडर से दूसरे कैलेंडर में परिवर्तित करता है

अंतर (डेटाटाइम 1, डेटाटाइम 2, यूनिट \\: दूसरा)

datetime2 से datetime1 घटाएं

from_iso8601 (स्ट्रिंग, कैलेंडर \\ Calendar.ISO)

आईएसओ 8601: 2004 द्वारा वर्णित "तिथि और दिन का समय" विस्तारित प्रारूप को बताता है

from_naive! (भोले-भाले, time_zone)

दिए गए NaiveDateTime को DateTime परिवर्तित करता है

from_naive (भोले-भाले, time_zone)

दिए गए NaiveDateTime को DateTime परिवर्तित करता है

from_unix! (पूर्णांक, इकाई \\: दूसरा, कैलेंडर \\ Calendar.ISO)

दिए गए यूनिक्स समय को DateTime परिवर्तित करता है

from_unix (पूर्णांक, इकाई \\: दूसरा, कैलेंडर \\ Calendar.ISO)

दिए गए यूनिक्स समय को DateTime परिवर्तित करता है

to_date(datetime)

किसी DateTime में DateTime को परिवर्तित करता है

to_iso8601 (डेटाटाइम, प्रारूप \\: विस्तारित)

दिए गए डेटाइम को ISO 8601: 2004 प्रारूप में रूपांतरित करता है

to_naive(datetime)

दिए गए NaiveDateTime में परिवर्तित करता है

to_string(datetime)

दिए गए datetime को उसके कैलेंडर के अनुसार एक स्ट्रिंग में परिवर्तित करता है

to_time(datetime)

एक DateTime को Time में परिवर्तित करता है

to_unix (डेटाइम, यूनिट \\: दूसरा)

दिए गए datetime को यूनिक्स समय में परिवर्तित करता है

ट्रंकट (डेटाइम, सटीक)

दिए गए डेट्रोइट को माइक्रोसेकंड फ़ील्ड के साथ दिए गए परिशुद्धता में काट दिया जाता है ( :microsecond , millisecond या :second )

utc_now (कैलेंडर \\ Calendar.ISO)

UTC में वर्तमान डेटाटाइम लौटाता है

प्रकार

टी ()

t() :: %DateTime{
  calendar: Calendar.calendar(),
  day: Calendar.day(),
  hour: Calendar.hour(),
  microsecond: Calendar.microsecond(),
  minute: Calendar.minute(),
  month: Calendar.month(),
  second: Calendar.second(),
  std_offset: Calendar.std_offset(),
  time_zone: Calendar.time_zone(),
  utc_offset: Calendar.utc_offset(),
  year: Calendar.year(),
  zone_abbr: Calendar.zone_abbr()
}

कार्य

तुलना करें (डेटाटाइम 1, डेटाटाइम 2) (1.4.0 के बाद से)

compare(Calendar.datetime(), Calendar.datetime()) :: :lt | :eq | :gt

दो डेटाटाइम संरचना की तुलना करता है।

रिटर्न :gt अगर पहले डेटाइम बाद में दूसरे से है और :lt इसके विपरीत के लिए :lt । यदि दो डेटाटाइम्स बराबर हैं :eq वापस आ गया है।

ध्यान दें कि जब तुलना की जाती है तो UTC और मानक दोनों ऑफसेट को ध्यान में रखा जाएगा।

उदाहरण

iex> dt1 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                 utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
iex> dt2 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                 utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
iex> DateTime.compare(dt1, dt2)
:gt

रूपांतरित करें (डेटाइम, कैलेंडर) (1.5.0 से)

convert!(Calendar.datetime(), Calendar.calendar()) :: t() | no_return()

दिए गए datetime को एक कैलेंडर से दूसरे कैलेंडर में परिवर्तित करता है।

यदि कैलेंडरों के बीच असंदिग्ध रूप से परिवर्तित करना संभव नहीं है (देखें। Calendar.compatible_calendars?/2 ), एक ArgumentError खड़ी है।

उदाहरण

कल्पना कीजिए कि कोई व्यक्ति Calendar.Holocene लागू करता है। पॉलीन, ग्रेगोरियन कैलेंडर पर आधारित एक कैलेंडर जो वर्तमान ग्रेगोरियन कैलेंडर में ठीक 10,000 साल जोड़ता है:

iex> dt1 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                 utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
iex> DateTime.convert!(dt1, Calendar.Holocene)
%DateTime{calendar: Calendar.Holocene, day: 29, hour: 23,
          microsecond: {0, 0}, minute: 0, month: 2, second: 7, std_offset: 0,
          time_zone: "America/Manaus", utc_offset: -14400, year: 12000,
          zone_abbr: "AMT"}

कन्वर्ट (डेटाटाइम, कैलेंडर) (1.5.0 के बाद से)

convert(Calendar.datetime(), Calendar.calendar()) ::
  {:ok, t()} | {:error, :incompatible_calendars}

दिए गए datetime को एक कैलेंडर से दूसरे कैलेंडर में परिवर्तित करता है।

यदि कैलेंडरों के बीच असंदिग्ध रूप से परिवर्तित करना संभव नहीं है (देखें। Calendar.compatible_calendars?/2 ), {:error, :incompatible_calendars} tuple वापस आ गया है।

उदाहरण

कल्पना कीजिए कि कोई व्यक्ति Calendar.Holocene लागू करता है। पॉलीन, ग्रेगोरियन कैलेंडर पर आधारित एक कैलेंडर जो वर्तमान ग्रेगोरियन कैलेंडर में ठीक 10,000 साल जोड़ता है:

iex> dt1 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                 utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
iex> DateTime.convert(dt1, Calendar.Holocene)
{:ok, %DateTime{calendar: Calendar.Holocene, day: 29, hour: 23,
                microsecond: {0, 0}, minute: 0, month: 2, second: 7, std_offset: 0,
                time_zone: "America/Manaus", utc_offset: -14400, year: 12000,
                zone_abbr: "AMT"}}

अंतर (डेटाटाइम 1, डेटाटाइम 2, यूनिट \\: दूसरा) (1.5.0 के बाद से)

datetime2 से datetime1 घटाएं।

इसका उत्तर System.time_unit/0 से उपलब्ध किसी भी unit में दिया जा सकता है।

लीप सेकंड को ध्यान में नहीं रखा जाता है।

यह फ़ंक्शन कैलेंडर में उस अंतर को लौटाता है जहां Calendar.ISO अनुसार सेकंड मापा जाता है।

उदाहरण

iex> dt1 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                 utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
iex> dt2 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                 utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
iex> DateTime.diff(dt1, dt2)
18000
iex> DateTime.diff(dt2, dt1)
-18000

from_iso8601 (स्ट्रिंग, कैलेंडर \\ Calendar.ISO) (1.4.0 के बाद से)

from_iso8601(String.t(), Calendar.calendar()) ::
  {:ok, t(), Calendar.utc_offset()} | {:error, atom()}

आईएसओ 8601: 2004 द्वारा वर्णित "तिथि और दिन का समय" विस्तारित प्रारूप को बताता है।

चूंकि आईएसओ 8601 में उचित समय क्षेत्र शामिल नहीं है, इसलिए दिए गए स्ट्रिंग को यूटीसी में बदल दिया जाएगा और सेकंड में इसकी ऑफसेट इस फ़ंक्शन के हिस्से के रूप में वापस आ जाएगी। इसलिए ऑफसेट जानकारी स्ट्रिंग में मौजूद होनी चाहिए।

मानक में निर्दिष्ट के रूप में, विभाजक "टी" को छोड़ दिया जा सकता है यदि वांछित है, तो इस फ़ंक्शन के भीतर कोई अस्पष्टता नहीं है।

कम सटीकता के साथ समय का प्रतिनिधित्व समर्थित नहीं हैं।

ध्यान दें कि जब ISO 8601 डेटासेटाइम को अगले दिन के शून्य घंटे के रूप में 24:00:00 निर्दिष्ट करने की अनुमति देता है, तो यह अंकन अमृत द्वारा समर्थित नहीं है।

उदाहरण

iex> {:ok, datetime, 0} = DateTime.from_iso8601("2015-01-23T23:50:07Z")
iex> datetime
#DateTime<2015-01-23 23:50:07Z>

iex> {:ok, datetime, 9000} = DateTime.from_iso8601("2015-01-23T23:50:07.123+02:30")
iex> datetime
#DateTime<2015-01-23 21:20:07.123Z>

iex> {:ok, datetime, 9000} = DateTime.from_iso8601("2015-01-23T23:50:07,123+02:30")
iex> datetime
#DateTime<2015-01-23 21:20:07.123Z>

iex> {:ok, datetime, 0} = DateTime.from_iso8601("-2015-01-23T23:50:07Z")
iex> datetime
#DateTime<-2015-01-23 23:50:07Z>

iex> {:ok, datetime, 9000} = DateTime.from_iso8601("-2015-01-23T23:50:07,123+02:30")
iex> datetime
#DateTime<-2015-01-23 21:20:07.123Z>

iex> DateTime.from_iso8601("2015-01-23P23:50:07")
{:error, :invalid_format}
iex> DateTime.from_iso8601("2015-01-23 23:50:07A")
{:error, :invalid_format}
iex> DateTime.from_iso8601("2015-01-23T23:50:07")
{:error, :missing_offset}
iex> DateTime.from_iso8601("2015-01-23 23:50:61")
{:error, :invalid_time}
iex> DateTime.from_iso8601("2015-01-32 23:50:07")
{:error, :invalid_date}

iex> DateTime.from_iso8601("2015-01-23T23:50:07.123-00:00")
{:error, :invalid_format}
iex> DateTime.from_iso8601("2015-01-23T23:50:07.123-00:60")
{:error, :invalid_format}

from_naive! (भोले-भाले, time_zone) (1.4.0 से)

from_naive!(NaiveDateTime.t(), Calendar.time_zone()) :: t()

दिए गए NaiveDateTime को DateTime परिवर्तित करता है।

यह NaiveDateTime को डालने के लिए एक समय क्षेत्र की अपेक्षा करता है। वर्तमान में यह केवल समय क्षेत्र के रूप में "आदि / UTC" का समर्थन करता है।

उदाहरण

iex> DateTime.from_naive!(~N[2016-05-24 13:26:08.003], "Etc/UTC")
#DateTime<2016-05-24 13:26:08.003Z>

from_naive (भोले-भाले, time_zone) (1.4.0 से)

from_naive(NaiveDateTime.t(), Calendar.time_zone()) :: {:ok, t()}

दिए गए NaiveDateTime को DateTime परिवर्तित करता है।

यह NaiveDateTime को डालने के लिए एक समय क्षेत्र की अपेक्षा करता है। वर्तमान में यह केवल समय क्षेत्र के रूप में "आदि / UTC" का समर्थन करता है।

उदाहरण

iex> {:ok, datetime} = DateTime.from_naive(~N[2016-05-24 13:26:08.003], "Etc/UTC")
iex> datetime
#DateTime<2016-05-24 13:26:08.003Z>

from_unix! (पूर्णांक, इकाई \\: दूसरा, कैलेंडर \\ Calendar.ISO)

from_unix!(integer(), :native | System.time_unit(), Calendar.calendar()) ::
  t()

दिए गए यूनिक्स समय को DateTime परिवर्तित करता है।

पूर्णांक System.convert_time_unit/3 अनुसार अलग-अलग इकाई में दिया जा सकता है और इसे आंतरिक रूप से microseconds में परिवर्तित किया जाएगा।

यूनिक्स समय हमेशा यूटीसी में होता है और इसलिए यूटीसी में डेटटाइम वापस कर दिया जाएगा।

उदाहरण

# An easy way to get the Unix epoch is passing 0 to this function
iex> DateTime.from_unix!(0)
#DateTime<1970-01-01 00:00:00Z>

iex> DateTime.from_unix!(1_464_096_368)
#DateTime<2016-05-24 13:26:08Z>

iex> DateTime.from_unix!(1_432_560_368_868_569, :microsecond)
#DateTime<2015-05-25 13:26:08.868569Z>

from_unix (पूर्णांक, इकाई \\: दूसरा, कैलेंडर \\ Calendar.ISO)

from_unix(integer(), :native | System.time_unit(), Calendar.calendar()) ::
  {:ok, t()} | {:error, atom()}

दिए गए यूनिक्स समय को DateTime परिवर्तित करता है।

पूर्णांक System.convert_time_unit/3 अनुसार अलग-अलग इकाई में दिया जा सकता है और इसे आंतरिक रूप से microseconds में परिवर्तित किया जाएगा।

यूनिक्स समय हमेशा यूटीसी में होता है और इसलिए यूटीसी में डेटटाइम वापस कर दिया जाएगा।

उदाहरण

iex> {:ok, datetime} = DateTime.from_unix(1_464_096_368)
iex> datetime
#DateTime<2016-05-24 13:26:08Z>

iex> {:ok, datetime} = DateTime.from_unix(1_432_560_368_868_569, :microsecond)
iex> datetime
#DateTime<2015-05-25 13:26:08.868569Z>

यूनिट System.time_unit/0 रूप में एक पूर्णांक भी हो सकती है:

iex> {:ok, datetime} = DateTime.from_unix(143_256_036_886_856, 1024)
iex> datetime
#DateTime<6403-03-17 07:05:22.320Z>

नकारात्मक-यूनिक्स बार समर्थित हैं, -62167219200 सेकंड तक, जो "0000-01-01T00: 00: 00Z" या 0 ग्रेगोरियन सेकंड के बराबर है।

TO_DATE (दिनांक)

to_date(t()) :: Date.t()

किसी DateTime में DateTime को परिवर्तित करता है।

क्योंकि Date समय और समय क्षेत्र की जानकारी नहीं है, इसलिए रूपांतरण के दौरान डेटा खो जाएगा।

उदाहरण

iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
iex> DateTime.to_date(dt)
~D[2000-02-29]

to_iso8601 (डेटाटाइम, प्रारूप \\: विस्तारित)

to_iso8601(Calendar.datetime(), :extended | :basic) :: String.t()

दिए गए डेटाइम को ISO 8601: 2004 प्रारूप में रूपांतरित करता है।

डिफ़ॉल्ट रूप से, DateTime.to_iso8601/2 रिटर्न "विस्तारित" प्रारूप में प्रारूपित किए जाते हैं, जो मानव पठनीयता के लिए हैं। यह भी :basic विकल्प के माध्यम से "मूल" प्रारूप का समर्थन करता है।

केवल परिवर्तित डेटासेटाइम का समर्थन करता है जो आईएसओ कैलेंडर में हैं, अन्य कैलेंडर से डेटाटाइम को बदलने का प्रयास करेंगे।

चेतावनी: आईएसओ 8601 डेटाटाइम प्रारूप में समय क्षेत्र नहीं है और न ही इसका संक्षिप्त नाम है, जिसका अर्थ है कि इस तरह के प्रारूप में परिवर्तित होने पर जानकारी खो जाती है।

उदाहरण

iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
iex> DateTime.to_iso8601(dt)
"2000-02-29T23:00:07+01:00"

iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "UTC",
...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                utc_offset: 0, std_offset: 0, time_zone: "Etc/UTC"}
iex> DateTime.to_iso8601(dt)
"2000-02-29T23:00:07Z"

iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
iex> DateTime.to_iso8601(dt, :extended)
"2000-02-29T23:00:07-04:00"

iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
iex> DateTime.to_iso8601(dt, :basic)
"20000229T230007-0400"

to_naive (दिनांक)

to_naive(t()) :: NaiveDateTime.t()

दिए गए NaiveDateTime में परिवर्तित करता है।

क्योंकि NaiveDateTime समय क्षेत्र की जानकारी नहीं रखता है, रूपांतरण के दौरान किसी भी समय क्षेत्र से संबंधित डेटा खो जाएगा।

उदाहरण

iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
...>                hour: 23, minute: 0, second: 7, microsecond: {0, 1},
...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
iex> DateTime.to_naive(dt)
~N[2000-02-29 23:00:07.0]

to_string (दिनांक)

to_string(Calendar.datetime()) :: String.t()

दिए गए datetime को उसके कैलेंडर के अनुसार एक स्ट्रिंग में परिवर्तित करता है।

उदाहरण

iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
iex> DateTime.to_string(dt)
"2000-02-29 23:00:07+01:00 CET Europe/Warsaw"

iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "UTC",
...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                utc_offset: 0, std_offset: 0, time_zone: "Etc/UTC"}
iex> DateTime.to_string(dt)
"2000-02-29 23:00:07Z"

iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
iex> DateTime.to_string(dt)
"2000-02-29 23:00:07-04:00 AMT America/Manaus"

iex> dt = %DateTime{year: -100, month: 12, day: 19, zone_abbr: "CET",
...>                hour: 3, minute: 20, second: 31, microsecond: {0, 0},
...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Stockholm"}
iex> DateTime.to_string(dt)
"-0100-12-19 03:20:31+01:00 CET Europe/Stockholm"

TO_TIME (दिनांक)

to_time(t()) :: Time.t()

एक DateTime को Time में परिवर्तित करता है।

क्योंकि Time दिनांक और न ही समय क्षेत्र की जानकारी नहीं है, रूपांतरण के दौरान डेटा खो जाएगा।

उदाहरण

iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
...>                hour: 23, minute: 0, second: 7, microsecond: {0, 1},
...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
iex> DateTime.to_time(dt)
~T[23:00:07.0]

to_unix (डेटाइम, यूनिट \\: दूसरा)

to_unix(Calendar.datetime(), System.time_unit()) :: integer()

दिए गए datetime को यूनिक्स समय में परिवर्तित करता है।

datetime का अनुमान है कि आईएसओ कैलेंडर का उपयोग एक वर्ष से अधिक या 0 के बराबर होगा।

यह System.convert_time_unit/3 अनुसार दिए गए यूनिट के साथ पूर्णांक लौटाएगा।

उदाहरण

iex> 1_464_096_368 |> DateTime.from_unix!() |> DateTime.to_unix()
1464096368

iex> dt = %DateTime{calendar: Calendar.ISO, day: 20, hour: 18, microsecond: {273806, 6},
...>                minute: 58, month: 11, second: 19, time_zone: "America/Montevideo",
...>                utc_offset: -10800, std_offset: 3600, year: 2014, zone_abbr: "UYST"}
iex> DateTime.to_unix(dt)
1416517099

iex> flamel = %DateTime{calendar: Calendar.ISO, day: 22, hour: 8, microsecond: {527771, 6},
...>                minute: 2, month: 3, second: 25, std_offset: 0, time_zone: "Etc/UTC",
...>                utc_offset: 0, year: 1418, zone_abbr: "UTC"}
iex> DateTime.to_unix(flamel)
-17412508655

ट्रंकट (डेटाइम, सटीक) (1.6.0 के बाद से)

truncate(t(), :microsecond | :millisecond | :second) :: t()

दिए गए डेट्रोइट को माइक्रोसेकंड फ़ील्ड के साथ दिए गए सटीक ( :microsecond , millisecond या :second ) के साथ जोड़ दिया जाता है।

उदाहरण

iex> dt1 = %DateTime{year: 2017, month: 11, day: 7, zone_abbr: "CET",
...>                 hour: 11, minute: 45, second: 18, microsecond: {123456, 6},
...>                 utc_offset: 3600, std_offset: 0, time_zone: "Europe/Paris"}
iex> DateTime.truncate(dt1, :microsecond)
#DateTime<2017-11-07 11:45:18.123456+01:00 CET Europe/Paris>

iex> dt2 = %DateTime{year: 2017, month: 11, day: 7, zone_abbr: "CET",
...>                 hour: 11, minute: 45, second: 18, microsecond: {123456, 6},
...>                 utc_offset: 3600, std_offset: 0, time_zone: "Europe/Paris"}
iex> DateTime.truncate(dt2, :millisecond)
#DateTime<2017-11-07 11:45:18.123+01:00 CET Europe/Paris>

iex> dt3 = %DateTime{year: 2017, month: 11, day: 7, zone_abbr: "CET",
...>                 hour: 11, minute: 45, second: 18, microsecond: {123456, 6},
...>                 utc_offset: 3600, std_offset: 0, time_zone: "Europe/Paris"}
iex> DateTime.truncate(dt3, :second)
#DateTime<2017-11-07 11:45:18+01:00 CET Europe/Paris>

utc_now (कैलेंडर \\ Calendar.ISO)

utc_now(Calendar.calendar()) :: t()

UTC में वर्तमान डेटाटाइम लौटाता है।

उदाहरण

iex> datetime = DateTime.utc_now()
iex> datetime.time_zone
"Etc/UTC"