Elixir 1.7

Date




elixir

Date

एक तारीख संरचना और कार्य।

दिनांक संरचना में फ़ील्ड वर्ष, माह, दिन और कैलेंडर शामिल हैं। नई तिथियां new/3 फ़ंक्शन के साथ या ~D sigil का उपयोग करके बनाई जा सकती हैं:

iex> ~D[2000-01-01]
~D[2000-01-01]

new/3 और sigil दोनों एक संरचना लौटाते हैं जहाँ दिनांक फ़ील्ड को सीधे एक्सेस किया जा सकता है:

iex> date = ~D[2000-01-01]
iex> date.year
2000
iex> date.month
1

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

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

तारीखों की तुलना करना

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

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

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

iex> Date.diff(~D[2010-04-17], ~D[1970-01-01])
14716

iex> Date.add(~D[1970-01-01], 14716)
~D[2010-04-17]

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

सारांश

प्रकार

t/0

कार्य

add/2

दी गई date को दिनों की संख्या जोड़ता है

compare/2

दो तारीखों की तुलना करता है

रूपांतरित करें (दिनांक, कैलेंडर)

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

परिवर्तित करें (दिनांक, कैलेंडर)

दिए गए date को उसके कैलेंडर से दिए गए calendar रूपांतरित करता है

day_of_week(date)

किसी दी गई date के सप्ताह के दिन की गणना करता है

days_in_month(date)

दिए गए date महीने में दिनों की संख्या लौटाता है

diff/2

दो दिनों के बीच के अंतर की गणना, पूर्ण दिनों में करता है

from_erl! (टपल, कैलेंडर \\ Calendar.ISO)

एक एर्लैंग तिथि टपल को रूपांतरित करता है लेकिन अमान्य तिथियों के लिए उठता है

from_erl (टपल, कैलेंडर \\ Calendar.ISO)

एक Date संरचना में एक इरलैंग तिथि टपल को रूपांतरित करता है

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

आईएसओ 8601: 2004 द्वारा वर्णित विस्तारित "डेट्स" प्रारूप को पार्स करता है

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

आईएसओ 8601: 2004 द्वारा वर्णित विस्तारित "डेट्स" प्रारूप को पार्स करता है

leap_year?(date)

true अगर दी गई date में वर्ष एक लीप वर्ष है

months_in_year(date)

दिए गए date वर्ष में महीनों की संख्या लौटाता है

नया (वर्ष, माह, दिन, कैलेंडर \\ Calendar.ISO)

एक नई आईएसओ तिथि बनाता है

रेंज (पहला, अंतिम)

तारीखों की एक श्रृंखला लौटाता है

to_erl(date)

दिए गए date को एक Erlang दिनांक tuple में रूपांतरित करता है

to_iso8601 (दिनांक, प्रारूप \\: विस्तारित)

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

to_string(date)

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

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

UTC में वर्तमान दिनांक लौटाता है

प्रकार

टी ()

t() :: %Date{
  calendar: Calendar.calendar(),
  day: Calendar.day(),
  month: Calendar.month(),
  year: Calendar.year()
}

कार्य

जोड़ें (दिनांक, दिन) (1.5.0 के बाद से)

add(Calendar.date(), integer()) :: t()

दी गई date को दिनों की संख्या जोड़ता है।

दिनों को ग्रेगोरियन दिनों के रूप में गिना जाता है। यह उसी कैलेंडर में दिया गया है जिस दिन इसे दिया गया था।

उदाहरण

iex> Date.add(~D[2000-01-03], -2)
~D[2000-01-01]
iex> Date.add(~D[2000-01-01], 2)
~D[2000-01-03]
iex> Date.add(~N[2000-01-01 09:00:00], 2)
~D[2000-01-03]
iex> Date.add(~D[-0010-01-01], -2)
~D[-0011-12-30]

तुलना करें (तारीख 1, तारीख 2) (1.4.0 से)

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

दो तारीखों की तुलना करता है।

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

उदाहरण

iex> Date.compare(~D[2016-04-16], ~D[2016-04-28])
:lt

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

iex> Date.compare(~D[2016-04-16], ~N[2016-04-28 01:23:45])
:lt
iex> Date.compare(~D[2016-04-16], ~N[2016-04-16 01:23:45])
:eq
iex> Date.compare(~N[2016-04-16 12:34:56], ~N[2016-04-16 01:23:45])
:eq

रूपांतरित करें (दिनांक, कैलेंडर) (1.5.0 से)

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

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

उदाहरण

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

iex> Date.convert!(~D[2000-01-01], Calendar.Holocene)
%Date{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1}

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

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

दिए गए date को उसके कैलेंडर से दिए गए calendar रूपांतरित करता है।

यदि कैलेंडर्स संगत हैं, या {:error, :incompatible_calendars} तो रिटर्न {:ok, date}

Calendar.compatible_calendars?/2 भी देखें

उदाहरण

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

iex> Date.convert(~D[2000-01-01], Calendar.Holocene)
{:ok, %Date{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1}}

day_of_week (तारीख) (1.4.0 के बाद से)

day_of_week(Calendar.date()) :: non_neg_integer()

किसी दी गई date के सप्ताह के दिन की गणना करता है।

सप्ताह के दिन को पूर्णांक के रूप में लौटाता है। आईएसओ 8601 कैलेंडर (डिफ़ॉल्ट) के लिए, यह 1 से 7 तक पूर्णांक है, जहां 1 सोमवार है और 7 रविवार है।

उदाहरण

iex> Date.day_of_week(~D[2016-10-31])
1
iex> Date.day_of_week(~D[2016-11-01])
2
iex> Date.day_of_week(~N[2016-11-01 01:23:45])
2
iex> Date.day_of_week(~D[-0015-10-30])
3

days_in_month (तारीख) (1.4.0 के बाद से)

days_in_month(Calendar.date()) :: Calendar.day()

दिए गए date महीने में दिनों की संख्या लौटाता है।

उदाहरण

iex> Date.days_in_month(~D[1900-01-13])
31
iex> Date.days_in_month(~D[1900-02-09])
28
iex> Date.days_in_month(~N[2000-02-20 01:23:45])
29

अंतर (तारीख 1, तारीख 2) (1.5.0 के बाद से)

diff(Calendar.date(), Calendar.date()) :: integer()

दो दिनों के बीच के अंतर की गणना, पूर्ण दिनों में करता है।

यह तारीखों के बीच ग्रेगोरियन दिनों की संख्या लौटाता है। केवल Date संरचनाएँ जो समान या संगत कैलेंडर का अनुसरण करती हैं उनकी तुलना इस तरह से की जा सकती है। यदि दो कैलेंडर संगत नहीं हैं, तो यह बढ़ेगा।

उदाहरण

iex> Date.diff(~D[2000-01-03], ~D[2000-01-01])
2
iex> Date.diff(~D[2000-01-01], ~D[2000-01-03])
-2
iex> Date.diff(~D[0000-01-02], ~D[-0001-12-30])
3
iex> Date.diff(~D[2000-01-01], ~N[2000-01-03 09:00:00])
-2

from_erl! (टपल, कैलेंडर \\ Calendar.ISO)

from_erl!(:calendar.date(), Calendar.calendar()) :: t()

एक एर्लैंग तिथि टपल को रूपांतरित करता है लेकिन अमान्य तिथियों के लिए उठता है।

उदाहरण

iex> Date.from_erl!({2000, 1, 1})
~D[2000-01-01]
iex> Date.from_erl!({2000, 13, 1})
** (ArgumentError) cannot convert {2000, 13, 1} to date, reason: :invalid_date

from_erl (टपल, कैलेंडर \\ Calendar.ISO)

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

एक Date संरचना में एक इरलैंग तिथि टपल को रूपांतरित करता है।

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

उदाहरण

iex> Date.from_erl({2000, 1, 1})
{:ok, ~D[2000-01-01]}
iex> Date.from_erl({2000, 13, 1})
{:error, :invalid_date}

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

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

आईएसओ 8601: 2004 द्वारा वर्णित विस्तारित "डेट्स" प्रारूप को पार्स करता है।

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

उदाहरण

iex> Date.from_iso8601!("2015-01-23")
~D[2015-01-23]
iex> Date.from_iso8601!("2015:01:23")
** (ArgumentError) cannot parse "2015:01:23" as date, reason: :invalid_format

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

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

आईएसओ 8601: 2004 द्वारा वर्णित विस्तारित "डेट्स" प्रारूप को पार्स करता है।

उदाहरण

iex> Date.from_iso8601("2015-01-23")
{:ok, ~D[2015-01-23]}

iex> Date.from_iso8601("2015:01:23")
{:error, :invalid_format}

iex> Date.from_iso8601("2015-01-32")
{:error, :invalid_date}

leap_year? (तारीख) (1.4.0 के बाद से)

leap_year?(Calendar.date()) :: boolean()

true अगर दी गई date में वर्ष एक लीप वर्ष है।

उदाहरण

iex> Date.leap_year?(~D[2000-01-01])
true
iex> Date.leap_year?(~D[2001-01-01])
false
iex> Date.leap_year?(~D[2004-01-01])
true
iex> Date.leap_year?(~D[1900-01-01])
false
iex> Date.leap_year?(~N[2004-01-01 01:23:45])
true

महीने_इन_ वर्ष (दिनांक) (1.7.0 से)

months_in_year(Calendar.date()) :: Calendar.month()

दिए गए date वर्ष में महीनों की संख्या लौटाता है।

उदाहरण

iex> Date.months_in_year(~D[1900-01-13])
12

नया (वर्ष, माह, दिन, कैलेंडर \\ Calendar.ISO)

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

एक नई आईएसओ तिथि बनाता है।

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

उदाहरण

iex> Date.new(2000, 1, 1)
{:ok, ~D[2000-01-01]}
iex> Date.new(2000, 13, 1)
{:error, :invalid_date}
iex> Date.new(2000, 2, 29)
{:ok, ~D[2000-02-29]}

iex> Date.new(2000, 2, 30)
{:error, :invalid_date}
iex> Date.new(2001, 2, 29)
{:error, :invalid_date}

रेंज (पहला, अंतिम) (1.5.0 से)

range(Date.t(), Date.t()) :: Date.Range.t()

तारीखों की एक श्रृंखला लौटाता है।

तारीखों की एक श्रृंखला उन असतत संख्याओं का प्रतिनिधित्व करती है जहाँ पहले और अंतिम मान मिलान वाले कैलेंडर के साथ दिनांक होते हैं।

तिथियों के रंग या तो बढ़ सकते हैं ( first <= last ) या घटते ( first > last )। वे हमेशा समावेशी भी होते हैं।

उदाहरण

iex> Date.range(~D[1999-01-01], ~D[2000-01-01])
#DateRange<~D[1999-01-01], ~D[2000-01-01]>

कई तिथियां Enumerable प्रोटोकॉल को लागू करती हैं, जिसका अर्थ है कि Enum मॉड्यूल में फ़ंक्शन का उपयोग श्रेणियों के साथ किया जा सकता है:

iex> range = Date.range(~D[2001-01-01], ~D[2002-01-01])
iex> Enum.count(range)
366
iex> Enum.member?(range, ~D[2001-02-01])
true
iex> Enum.reduce(range, 0, fn _date, acc -> acc - 1 end)
-366

to_erl (तारीख)

to_erl(Calendar.date()) :: :calendar.date()

दिए गए date को एक Erlang दिनांक tuple में रूपांतरित करता है।

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

उदाहरण

iex> Date.to_erl(~D[2000-01-01])
{2000, 1, 1}

iex> Date.to_erl(~N[2000-01-01 00:00:00])
{2000, 1, 1}

to_iso8601 (दिनांक, प्रारूप \\: विस्तारित)

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

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

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

केवल उन तिथियों को परिवर्तित करने का समर्थन करता है जो आईएसओ कैलेंडर में हैं, या अन्य कैलेंडर जिसमें दिन भी आधी रात को शुरू होते हैं। अन्य कैलेंडर से तिथियों को परिवर्तित करने का प्रयास एक ArgumentError को बढ़ाएगा।

उदाहरण

iex> Date.to_iso8601(~D[2000-02-28])
"2000-02-28"

iex> Date.to_iso8601(~D[2000-02-28], :basic)
"20000228"

iex> Date.to_iso8601(~N[2000-02-28 00:00:00])
"2000-02-28"

to_string (तारीख)

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

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

उदाहरण

iex> Date.to_string(~D[2000-02-28])
"2000-02-28"
iex> Date.to_string(~N[2000-02-28 01:23:45])
"2000-02-28"
iex> Date.to_string(~D[-0100-12-15])
"-0100-12-15"

utc_today (कैलेंडर \\ Calendar.ISO) (1.4.0 से)

utc_today(Calendar.calendar()) :: t()

UTC में वर्तमान दिनांक लौटाता है।

उदाहरण

iex> date = Date.utc_today()
iex> date.year >= 2016
true