Elixir 1.7

NaiveDateTime




elixir

NaiveDateTime

एक NaiveDateTime संरचना (एक समय क्षेत्र के बिना) और कार्य करता है।

NaiveDateTime संरचना में वर्ष, माह, दिन, घंटा, मिनट, दूसरा, माइक्रोसेकंड और कैलेंडर शामिल हैं। नए भोले डेटासेट को new/2 और new/8 कार्यों के साथ बनाया जा सकता है या ~N सर्जन का उपयोग करके:

iex> ~N[2000-01-01 23:00:07]
~N[2000-01-01 23:00:07]

संरचना में दिनांक और समय फ़ील्ड को सीधे एक्सेस किया जा सकता है:

iex> naive = ~N[2000-01-01 23:00:07]
iex> naive.year
2000
iex> naive.second
7

हम उन्हें "भोला" कहते हैं क्योंकि इस डेटाटाइम प्रतिनिधित्व में समय क्षेत्र नहीं है। इसका अर्थ है कि दुनिया भर में कुछ क्षेत्रों में डेटाटाइम वास्तव में मौजूद नहीं हो सकता है, भले ही यह वैध हो।

उदाहरण के लिए, जब एक क्षेत्र द्वारा दिन की बचत के परिवर्तन लागू होते हैं, तो घड़ी आम तौर पर एक घंटे आगे या पीछे चलती है। इसका मतलब यह है कि कुछ डेटाइम कभी नहीं होते हैं या एक से अधिक बार हो सकते हैं। चूंकि NaiveDateTime एक समय क्षेत्र के विरुद्ध मान्य नहीं है, इसलिए ऐसी त्रुटियां किसी का ध्यान नहीं जाएगा।

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

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

भोली तारीख बार की तुलना

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

युगों का उपयोग करना

add/3 और diff/3 फ़ंक्शन का उपयोग दिनांक समय के साथ कंप्यूटिंग या इंस्टेंट के बीच सेकंड की संख्या प्राप्त करने के लिए किया जा सकता है। उदाहरण के लिए, यदि यूनिक्स युग (1970-01-01 00:00:00) से सेकंड की संख्या की गणना करने में रुचि है:

iex> NaiveDateTime.diff(~N[2010-04-17 14:00:00], ~N[1970-01-01 00:00:00])
1271512800

iex> NaiveDateTime.add(~N[1970-01-01 00:00:00], 1_271_512_800)
~N[2010-04-17 14:00:00]

उन कार्यों को सामान्य युगों से निपटने के लिए अनुकूलित किया जाता है, जैसे कि यूनिक्स एपोच ऊपर या ग्रेगोरियन एपोच (0000-01-01 00:00:00)।

सारांश

प्रकार

t/0

कार्य

add/3

NaiveDateTime लिए एक निर्दिष्ट समय जोड़ता है

compare/2

दो NaiveDateTime तुलना करता है

रूपांतरित करें (भोले-भाले, कैलेंडर)

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

कन्वर्ट (भोले-भाले, कैलेंडर)

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

diff/3

naive_datetime2 से naive_datetime1 को naive_datetime1

from_erl! (tuple, microsecond \\ {0, 0}, कैलेंडर \\ Calendar.ISO)

एक NaiveDateTime संरचना के लिए एक NaiveDateTime टपल को रूपांतरित करता है

from_erl (tuple, microsecond \\ {0, 0}, कैलेंडर \\ Calendar.ISO)

एक NaiveDateTime संरचना के लिए एक NaiveDateTime टपल को रूपांतरित करता है

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

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

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

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

new/2

दिनांक और समय की संरचना से एक भोले डेटाटाइम बनाता है

new/8

एक नया ISO भोली डेटाइम बनाता है

to_date(naive_date_time)

एक NaiveDateTime को Date में परिवर्तित करता है

to_erl(naive_datetime)

एक NaiveDateTime संरचना को Erlang NaiveDateTime टपल में रूपांतरित करता है

to_iso8601 (भोले-भाले, प्रारूप \\: विस्तारित)

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

to_string(naive_datetime)

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

to_time(naive_datetime)

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

truncate (भोले-भाले, सटीक)

दिए गए सटीक सूक्ष्मदर्शी के साथ माइक्रोसेकंड फ़ील्ड के साथ दिए गए भोले डेटाटाइम को लौटाता है :microsecond ( :microsecond :millisecond या :second )

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

UTC में वर्तमान भोली तारीख लौटाता है

प्रकार

टी ()

t() :: %NaiveDateTime{
  calendar: Calendar.calendar(),
  day: Calendar.day(),
  hour: Calendar.hour(),
  microsecond: Calendar.microsecond(),
  minute: Calendar.minute(),
  month: Calendar.month(),
  second: Calendar.second(),
  year: Calendar.year()
}

कार्य

जोड़ें (भोले-भाले, पूर्णांक, इकाई \\: दूसरा) (1.4.0 के बाद से)

add(t(), integer(), System.time_unit()) :: t()

NaiveDateTime लिए एक निर्दिष्ट समय जोड़ता है।

System.time_unit/0 से उपलब्ध किसी भी unit में integer को स्वीकार करता है। नकारात्मक मूल्य समय में पीछे की ओर बढ़ेंगे।

यह ऑपरेशन तभी संभव है जब दोनों कैलेंडर Calendar.ISO लिए परिवर्तनीय हों।

उदाहरण

# adds seconds by default
iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], 2)
~N[2014-10-02 00:29:12]

# accepts negative offsets
iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], -2)
~N[2014-10-02 00:29:08]

# can work with other units
iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], 2_000, :millisecond)
~N[2014-10-02 00:29:12]

# keeps the same precision
iex> NaiveDateTime.add(~N[2014-10-02 00:29:10.021], 21, :second)
~N[2014-10-02 00:29:31.021]

# changes below the precision will not be visible
iex> hidden = NaiveDateTime.add(~N[2014-10-02 00:29:10], 21, :millisecond)
iex> hidden.microsecond # ~N[2014-10-02 00:29:10]
{21000, 0}

# from Gregorian seconds
iex> NaiveDateTime.add(~N[0000-01-01 00:00:00], 63_579_428_950)
~N[2014-10-02 00:29:10]

तुलना करें (naive_datetime1, naive_datetime2) (1.4.0 से)

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

दो NaiveDateTime तुलना करता है।

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

उदाहरण

iex> NaiveDateTime.compare(~N[2016-04-16 13:30:15], ~N[2016-04-28 16:19:25])
:lt
iex> NaiveDateTime.compare(~N[2016-04-16 13:30:15.1], ~N[2016-04-16 13:30:15.01])
:gt

इस फ़ंक्शन का उपयोग समय क्षेत्र की जानकारी के बिना डेटटाइम की तुलना करने के लिए भी किया जा सकता है:

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> NaiveDateTime.compare(dt, ~N[2000-02-29 23:00:07])
:eq
iex> NaiveDateTime.compare(dt, ~N[2000-01-29 23:00:07])
:gt
iex> NaiveDateTime.compare(dt, ~N[2000-03-29 23:00:07])
:lt

कन्वर्ट। (भोले-भाले, कैलेंडर) (1.5.0 से)

convert!(Calendar.naive_datetime(), Calendar.calendar()) :: t()

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

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

उदाहरण

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

iex> NaiveDateTime.convert!(~N[2000-01-01 13:30:15], Calendar.Holocene)
%NaiveDateTime{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1,
               hour: 13, minute: 30, second: 15, microsecond: {0, 0}}

कन्वर्ट (भोले-भाले, कैलेंडर) (1.5.0 से)

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

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

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

उदाहरण

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

iex> NaiveDateTime.convert(~N[2000-01-01 13:30:15], Calendar.Holocene)
{:ok, %NaiveDateTime{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1,
                     hour: 13, minute: 30, second: 15, microsecond: {0, 0}}}

अंतर (naive_datetime1, naive_datetime2, unit \\: दूसरा) (1.4.0 से)

diff(t(), t(), System.time_unit()) :: integer()

naive_datetime2 से naive_datetime2 को naive_datetime1

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

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

उदाहरण

iex> NaiveDateTime.diff(~N[2014-10-02 00:29:12], ~N[2014-10-02 00:29:10])
2
iex> NaiveDateTime.diff(~N[2014-10-02 00:29:12], ~N[2014-10-02 00:29:10], :microsecond)
2_000_000
iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10.042], ~N[2014-10-02 00:29:10.021], :millisecond)
21
iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10], ~N[2014-10-02 00:29:12])
-2
iex> NaiveDateTime.diff(~N[-0001-10-02 00:29:10], ~N[-0001-10-02 00:29:12])
-2

# to Gregorian seconds
iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10], ~N[0000-01-01 00:00:00])
63579428950

from_erl! (tuple, microsecond \\ {0, 0}, कैलेंडर \\ Calendar.ISO)

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

एक NaiveDateTime संरचना के लिए एक NaiveDateTime टपल को रूपांतरित करता है।

यदि डेटाटाइम अमान्य है, तो उठाता है। अमान्य ISO कैलेंडर दिनांक को परिवर्तित करने का प्रयास करने से त्रुटि उत्पन्न होगी।

उदाहरण

iex> NaiveDateTime.from_erl!({{2000, 1, 1}, {13, 30, 15}})
~N[2000-01-01 13:30:15]
iex> NaiveDateTime.from_erl!({{2000, 1, 1}, {13, 30, 15}}, {5000, 3})
~N[2000-01-01 13:30:15.005]
iex> NaiveDateTime.from_erl!({{2000, 13, 1}, {13, 30, 15}})
** (ArgumentError) cannot convert {{2000, 13, 1}, {13, 30, 15}} to naive datetime, reason: :invalid_date

from_erl (tuple, microsecond \\ {0, 0}, कैलेंडर \\ Calendar.ISO)

from_erl(:calendar.datetime(), Calendar.microsecond(), Calendar.calendar()) ::
  {:ok, t()} | {:error, atom()}

एक NaiveDateTime संरचना के लिए एक NaiveDateTime टपल को रूपांतरित करता है।

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

उदाहरण

iex> NaiveDateTime.from_erl({{2000, 1, 1}, {13, 30, 15}})
{:ok, ~N[2000-01-01 13:30:15]}
iex> NaiveDateTime.from_erl({{2000, 1, 1}, {13, 30, 15}}, {5000, 3})
{:ok, ~N[2000-01-01 13:30:15.005]}
iex> NaiveDateTime.from_erl({{2000, 13, 1}, {13, 30, 15}})
{:error, :invalid_date}
iex> NaiveDateTime.from_erl({{2000, 13, 1}, {13, 30, 15}})
{:error, :invalid_date}

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

from_iso8601!(String.t(), Calendar.calendar()) :: t() | no_return()

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

यदि प्रारूप अमान्य है, तो उठाता है।

उदाहरण

iex> NaiveDateTime.from_iso8601!("2015-01-23T23:50:07.123Z")
~N[2015-01-23 23:50:07.123]
iex> NaiveDateTime.from_iso8601!("2015-01-23T23:50:07,123Z")
~N[2015-01-23 23:50:07.123]
iex> NaiveDateTime.from_iso8601!("2015-01-23P23:50:07")
** (ArgumentError) cannot parse "2015-01-23P23:50:07" as naive datetime, reason: :invalid_format

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

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

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

टाइम ज़ोन ऑफ़सेट्स को स्ट्रिंग में शामिल किया जा सकता है, लेकिन उन्हें बस छोड़ दिया जाएगा क्योंकि ऐसी जानकारी भोली तारीख के समय में शामिल नहीं है।

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

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

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

उदाहरण

iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07")
{:ok, ~N[2015-01-23 23:50:07]}
iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07")
{:ok, ~N[2015-01-23 23:50:07]}
iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07Z")
{:ok, ~N[2015-01-23 23:50:07]}

iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07.0")
{:ok, ~N[2015-01-23 23:50:07.0]}
iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07,0123456")
{:ok, ~N[2015-01-23 23:50:07.012345]}
iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07.0123456")
{:ok, ~N[2015-01-23 23:50:07.012345]}
iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123Z")
{:ok, ~N[2015-01-23 23:50:07.123]}

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

iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123+02:30")
{:ok, ~N[2015-01-23 23:50:07.123]}
iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123+00:00")
{:ok, ~N[2015-01-23 23:50:07.123]}
iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-02:30")
{:ok, ~N[2015-01-23 23:50:07.123]}
iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-00:00")
{:error, :invalid_format}
iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-00:60")
{:error, :invalid_format}
iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-24:00")
{:error, :invalid_format}

नया (दिनांक, समय)

new(Date.t(), Time.t()) :: {:ok, t()}

दिनांक और समय की संरचना से एक भोले डेटाटाइम बनाता है।

उदाहरण

iex> NaiveDateTime.new(~D[2010-01-13], ~T[23:00:07.005])
{:ok, ~N[2010-01-13 23:00:07.005]}

नया (वर्ष, महीना, दिन, घंटा, मिनट, दूसरा, microsecond \\ {0, 0}, कैलेंडर \\ Calendar.ISO)

new(
  Calendar.year(),
  Calendar.month(),
  Calendar.day(),
  Calendar.hour(),
  Calendar.minute(),
  Calendar.second(),
  Calendar.microsecond(),
  Calendar.calendar()
) :: {:ok, t()} | {:error, atom()}

एक नया ISO भोली डेटाइम बनाता है।

सभी मानों को पूर्णांक होने की अपेक्षा करता है। रिटर्न {:ok, naive_datetime} यदि प्रत्येक प्रविष्टि अपनी उपयुक्त सीमा को फिट करता है, तो {:error, reason} अन्यथा वापस करता है।

उदाहरण

iex> NaiveDateTime.new(2000, 1, 1, 0, 0, 0)
{:ok, ~N[2000-01-01 00:00:00]}
iex> NaiveDateTime.new(2000, 13, 1, 0, 0, 0)
{:error, :invalid_date}
iex> NaiveDateTime.new(2000, 2, 29, 0, 0, 0)
{:ok, ~N[2000-02-29 00:00:00]}
iex> NaiveDateTime.new(2000, 2, 30, 0, 0, 0)
{:error, :invalid_date}
iex> NaiveDateTime.new(2001, 2, 29, 0, 0, 0)
{:error, :invalid_date}

iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, {0, 1})
{:ok, ~N[2000-01-01 23:59:59.0]}
iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, 999_999)
{:ok, ~N[2000-01-01 23:59:59.999999]}
iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 60, 999_999)
{:ok, ~N[2000-01-01 23:59:60.999999]}
iex> NaiveDateTime.new(2000, 1, 1, 24, 59, 59, 999_999)
{:error, :invalid_time}
iex> NaiveDateTime.new(2000, 1, 1, 23, 60, 59, 999_999)
{:error, :invalid_time}
iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 61, 999_999)
{:error, :invalid_time}
iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, 1_000_000)
{:error, :invalid_time}

iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, {0, 1}, Calendar.ISO)
{:ok, ~N[2000-01-01 23:59:59.0]}

TO_DATE (naive_date_time)

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

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

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

उदाहरण

iex> NaiveDateTime.to_date(~N[2002-01-13 23:00:07])
~D[2002-01-13]

to_erl (naive_datetime)

to_erl(Calendar.naive_datetime()) :: :calendar.datetime()

एक NaiveDateTime संरचना को Erlang NaiveDateTime टपल में रूपांतरित करता है।

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

चेतावनी: परिशुद्धता का नुकसान हो सकता है, क्योंकि एर्लांग समय केवल घंटे / मिनट / सेकंड तक ट्यूप करता है।

उदाहरण

iex> NaiveDateTime.to_erl(~N[2000-01-01 13:30:15])
{{2000, 1, 1}, {13, 30, 15}}

इस फ़ंक्शन का उपयोग समय क्षेत्र की जानकारी के बिना डेटाइम को एरल प्रारूप में बदलने के लिए भी किया जा सकता है:

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> NaiveDateTime.to_erl(dt)
{{2000, 2, 29}, {23, 00, 07}}

to_iso8601 (भोले-भाले, प्रारूप \\: विस्तारित)

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

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

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

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

उदाहरण

iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13])
"2000-02-28T23:00:13"

iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13.001])
"2000-02-28T23:00:13.001"

iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13.001], :basic)
"20000228T230013.001"

इस फ़ंक्शन का उपयोग समय क्षेत्र की जानकारी के बिना डेटाइम को आईएसओ 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> NaiveDateTime.to_iso8601(dt)
"2000-02-29T23:00:07"

to_string (naive_datetime)

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

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

उदाहरण

iex> NaiveDateTime.to_string(~N[2000-02-28 23:00:13])
"2000-02-28 23:00:13"
iex> NaiveDateTime.to_string(~N[2000-02-28 23:00:13.001])
"2000-02-28 23:00:13.001"
iex> NaiveDateTime.to_string(~N[-0100-12-15 03:20:31])
"-0100-12-15 03:20:31"

इस फ़ंक्शन का उपयोग समय क्षेत्र की जानकारी के बिना डेटाइम को स्ट्रिंग में बदलने के लिए भी किया जा सकता है:

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> NaiveDateTime.to_string(dt)
"2000-02-29 23:00:07"

TO_TIME (naive_datetime)

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

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

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

उदाहरण

iex> NaiveDateTime.to_time(~N[2002-01-13 23:00:07])
~T[23:00:07]

truncate (भोले-भाले, सटीक) (1.6.0 के बाद से)

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

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

उदाहरण

iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :microsecond)
~N[2017-11-06 00:23:51.123456]

iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :millisecond)
~N[2017-11-06 00:23:51.123]

iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :second)
~N[2017-11-06 00:23:51]

utc_now (कैलेंडर \\ Calendar.ISO) (1.4.0 के बाद से)

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

UTC में वर्तमान भोली तारीख लौटाता है।

NaiveDateTime विपरीत, जब भी संभव हो DateTime.utc_now/0 का उपयोग करना पसंद करें, यह समय क्षेत्र की जानकारी रखेगा।

उदाहरण

iex> naive_datetime = NaiveDateTime.utc_now()
iex> naive_datetime.year >= 2016
true