Elixir 1.7

Time




elixir

Time

एक समय संरचना और कार्य।

समय की संरचना में फ़ील्ड घंटे, मिनट, सेकंड और माइक्रोसेकंड शामिल हैं। नया समय new/4 फ़ंक्शन के साथ या ~T sigil का उपयोग करके बनाया जा सकता है:

iex> ~T[23:00:07.001]
~T[23:00:07.001]

new/4 और sigil दोनों एक संरचना लौटाते हैं जहाँ समय क्षेत्र सीधे पहुँचा जा सकता है:

iex> time = ~T[23:00:07.001]
iex> time.hour
23
iex> time.microsecond
{1000, 3}

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

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

तुलना के समय

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

सारांश

प्रकार

t/0

कार्य

जोड़ें (समय, संख्या, इकाई \\: दूसरा)

दिए गए time में unit की number जोड़ता है

compare/2

दो समय संरचनाओं की तुलना करता है

परिवर्तित करें। (समय, कैलेंडर)

Time.convert/2 समान, लेकिन दो कैलेंडरों के बीच रूपांतरण संभव नहीं होने पर एक ArgumentError बढ़ाता है

कन्वर्ट (समय, कैलेंडर)

एक अलग कैलेंडर को time दिया जाता है

अंतर (समय 1, समय 2, इकाई \\: दूसरा)

केवल घंटे, मिनट, दूसरे और माइक्रोसेकंड पर विचार करते हुए, दो बार के बीच का अंतर लौटाता है

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

एक एरलैंग टाइम टपल को Time स्ट्रक्चर में परिवर्तित करता है

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

एक एरलैंग टाइम टपल को Time स्ट्रक्चर में परिवर्तित करता है

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

आईएसओ 8601 द्वारा वर्णित विस्तारित "स्थानीय समय" प्रारूप : 2004

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

आईएसओ 8601 द्वारा वर्णित विस्तारित "स्थानीय समय" प्रारूप : 2004

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

एक नया समय बनाता है

to_erl(time)

एक एर्लांग समय टपल को time दिया जाता है

to_iso8601 (समय, प्रारूप \\: विस्तारित)

आईएसओ 8601 को दिए गए समय को परिवर्तित करता है : 2004

to_string(time)

दिए गए time को एक स्ट्रिंग में परिवर्तित करता है

छोटा (समय, सटीक)

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

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

UTC में वर्तमान समय लौटाता है

प्रकार

टी ()

t() :: %Time{
  calendar: Calendar.calendar(),
  hour: Calendar.hour(),
  microsecond: Calendar.microsecond(),
  minute: Calendar.minute(),
  second: Calendar.second()
}

कार्य

जोड़ें (समय, संख्या, इकाई \\: दूसरा) (1.6.0 के बाद से)

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

दिए गए time में unit की number जोड़ता है।

यह फ़ंक्शन Calendar.ISO अनुसार मापी गई number स्वीकार करता है। समय उसी कैलेंडर में लौटाया जाता है जैसा कि उसमें दिया गया था।

ध्यान दें कि परिणाम मूल्य दिन के समय का प्रतिनिधित्व करता है, जिसका अर्थ है कि यह चक्रीय है, उदाहरण के लिए, यह आईएसओ कैलेंडर के लिए 24 घंटे से अधिक कभी नहीं जाएगा।

उदाहरण

iex> Time.add(~T[10:00:00], 27000)
~T[17:30:00.000000]
iex> Time.add(~T[11:00:00.005], 2400)
~T[11:40:00.005000]
iex> Time.add(~T[00:00:00], 86_399_999, :millisecond)
~T[23:59:59.999000]
iex> Time.add(~T[17:10:05], 86400)
~T[17:10:05.000000]
iex> Time.add(~T[23:00:00], -60)
~T[22:59:00.000000]

तुलना करें (time1, time2) (1.4.0 से)

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

दो समय संरचनाओं की तुलना करता है।

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

उदाहरण

iex> Time.compare(~T[16:04:16], ~T[16:04:28])
:lt
iex> Time.compare(~T[16:04:16], ~T[16:04:16])
:eq
iex> Time.compare(~T[16:04:16.01], ~T[16:04:16.001])
:gt

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

iex> Time.compare(~N[1900-01-01 16:04:16], ~N[2015-01-01 16:04:16])
:eq
iex> Time.compare(~N[2015-01-01 16:04:16], ~N[2015-01-01 16:04:28])
:lt
iex> Time.compare(~N[2015-01-01 16:04:16.01], ~N[2000-01-01 16:04:16.001])
:gt

परिवर्तित करें। (समय, कैलेंडर) (1.5.0 के बाद से)

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

Time.convert/2 समान, लेकिन दो कैलेंडर के बीच रूपांतरण संभव नहीं होने पर एक ArgumentError बढ़ाता है।

उदाहरण

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

iex> Time.convert!(~T[13:30:15], Calendar.Holocene)
%Time{calendar: Calendar.Holocene, hour: 13, minute: 30, second: 15, microsecond: {0, 0}}

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

convert(Calendar.time(), Calendar.calendar()) ::
  {:ok, t()} | {:error, atom()}

एक अलग कैलेंडर को time दिया जाता है।

रिटर्न {:ok, time} यदि रूपांतरण सफल था, या {:error, reason} यदि यह नहीं था, तो किसी कारण से।

उदाहरण

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

iex> Time.convert(~T[13:30:15], Calendar.Holocene)
{:ok, %Time{calendar: Calendar.Holocene, hour: 13, minute: 30, second: 15, microsecond: {0, 0}}}

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

diff(Calendar.time(), Calendar.time(), System.time_unit()) :: integer()

केवल घंटे, मिनट, दूसरे और माइक्रोसेकंड पर विचार करते हुए, दो बार के बीच का अंतर लौटाता है।

compare/2 फ़ंक्शन के साथ Time संरचना और Time सहित अन्य संरचनाओं का उपयोग किया जा सकता है। यदि उदाहरण के लिए एक NaiveDateTime या DateTime पारित किया जाता है, तो केवल घंटा, महीना, दूसरा और माइक्रोसेकंड माना जाता है। अंतर की गणना करते समय किसी दिनांक या समय क्षेत्र के बारे में किसी भी अतिरिक्त जानकारी को अनदेखा कर दिया जाता है।

इसका उत्तर System.time_unit/0 से उपलब्ध किसी भी unit में दिया जा सकता है। यदि पहली इकाई दूसरी से छोटी है, तो एक ऋणात्मक संख्या वापस आ जाती है।

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

उदाहरण

iex> Time.diff(~T[00:29:12], ~T[00:29:10])
2

# When passing a [`NaiveDateTime`](NaiveDateTime.html) the date part is ignored.
iex> Time.diff(~N[2017-01-01 00:29:12], ~T[00:29:10])
2

# Two [`NaiveDateTime`](NaiveDateTime.html) structs could have big differences in the date
# but only the time part is considered.
iex> Time.diff(~N[2017-01-01 00:29:12], ~N[1900-02-03 00:29:10])
2

iex> Time.diff(~T[00:29:12], ~T[00:29:10], :microsecond)
2_000_000
iex> Time.diff(~T[00:29:10], ~T[00:29:12], :microsecond)
-2_000_000

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

from_erl!(:calendar.time(), Calendar.microsecond(), Calendar.calendar()) ::
  t()

एक एरलैंग टाइम टपल को Time स्ट्रक्चर में परिवर्तित करता है।

उदाहरण

iex> Time.from_erl!({23, 30, 15})
~T[23:30:15]
iex> Time.from_erl!({23, 30, 15}, {5000, 3})
~T[23:30:15.005]
iex> Time.from_erl!({24, 30, 15})
** (ArgumentError) cannot convert {24, 30, 15} to time, reason: :invalid_time

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

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

एक एरलैंग टाइम टपल को Time स्ट्रक्चर में परिवर्तित करता है।

उदाहरण

iex> Time.from_erl({23, 30, 15}, {5000, 3})
{:ok, ~T[23:30:15.005]}
iex> Time.from_erl({24, 30, 15})
{:error, :invalid_time}

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

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

आईएसओ 8601 द्वारा वर्णित विस्तारित "स्थानीय समय" प्रारूप : 2004

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

उदाहरण

iex> Time.from_iso8601!("23:50:07,123Z")
~T[23:50:07.123]
iex> Time.from_iso8601!("23:50:07.123Z")
~T[23:50:07.123]
iex> Time.from_iso8601!("2015:01:23 23-50-07")
** (ArgumentError) cannot parse "2015:01:23 23-50-07" as time, 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> Time.from_iso8601("23:50:07")
{:ok, ~T[23:50:07]}
iex> Time.from_iso8601("23:50:07Z")
{:ok, ~T[23:50:07]}
iex> Time.from_iso8601("T23:50:07Z")
{:ok, ~T[23:50:07]}

iex> Time.from_iso8601("23:50:07,0123456")
{:ok, ~T[23:50:07.012345]}
iex> Time.from_iso8601("23:50:07.0123456")
{:ok, ~T[23:50:07.012345]}
iex> Time.from_iso8601("23:50:07.123Z")
{:ok, ~T[23:50:07.123]}

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

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

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

एक नया समय बनाता है।

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

ध्यान दें कि लीप सेकंड के मामले में समय 60 सेकंड हो सकता है। माइक्रोसेकंड भी एक सटीकता के साथ दिया जा सकता है, जो 0 और 6 के बीच पूर्णांक होना चाहिए।

उदाहरण

iex> Time.new(0, 0, 0, 0)
{:ok, ~T[00:00:00.000000]}
iex> Time.new(23, 59, 59, 999_999)
{:ok, ~T[23:59:59.999999]}
iex> Time.new(23, 59, 60, 999_999)
{:ok, ~T[23:59:60.999999]}

# Time with microseconds and their precision
iex> Time.new(23, 59, 60, {10_000, 2})
{:ok, ~T[23:59:60.01]}

iex> Time.new(24, 59, 59, 999_999)
{:error, :invalid_time}
iex> Time.new(23, 60, 59, 999_999)
{:error, :invalid_time}
iex> Time.new(23, 59, 61, 999_999)
{:error, :invalid_time}
iex> Time.new(23, 59, 59, 1_000_000)
{:error, :invalid_time}

# Invalid precision
Time.new(23, 59, 59, {999_999, 10})
{:error, :invalid_time}

to_erl (समय)

to_erl(Calendar.time()) :: :calendar.time()

एक एर्लांग समय टपल को time दिया जाता है।

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

उदाहरण

iex> Time.to_erl(~T[23:30:15.999])
{23, 30, 15}

iex> Time.to_erl(~N[2010-04-17 23:30:15.999])
{23, 30, 15}

to_iso8601 (समय, प्रारूप \\: विस्तारित)

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

आईएसओ 8601 को दिए गए समय को परिवर्तित करता है : 2004

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

उदाहरण

iex> Time.to_iso8601(~T[23:00:13])
"23:00:13"

iex> Time.to_iso8601(~T[23:00:13.001])
"23:00:13.001"

iex> Time.to_iso8601(~T[23:00:13.001], :basic)
"230013.001"

iex> Time.to_iso8601(~N[2010-04-17 23:00:13])
"23:00:13"

to_string (समय)

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

दिए गए time को एक स्ट्रिंग में परिवर्तित करता है।

उदाहरण

iex> Time.to_string(~T[23:00:00])
"23:00:00"
iex> Time.to_string(~T[23:00:00.001])
"23:00:00.001"
iex> Time.to_string(~T[23:00:00.123456])
"23:00:00.123456"

iex> Time.to_string(~N[2015-01-01 23:00:00.001])
"23:00:00.001"
iex> Time.to_string(~N[2015-01-01 23:00:00.123456])
"23:00:00.123456"

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

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

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

उदाहरण

iex> Time.truncate(~T[01:01:01.123456], :microsecond)
~T[01:01:01.123456]

iex> Time.truncate(~T[01:01:01.123456], :millisecond)
~T[01:01:01.123]

iex> Time.truncate(~T[01:01:01.123456], :second)
~T[01:01:01]

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

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

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

उदाहरण

iex> time = Time.utc_now()
iex> time.hour >= 0
true