ब्यूटी के लिए बुकिंग

"तारीख और समय तो हम छोटे बच्चों को सिखाते हैं। ये कितना मुश्किल हो सकता है?"

बहुत से प्रोग्रामर ने यह गलती की है, और उसके बाद का अनुभव आम तौर पर उनके स्वास्थ्य और खुशी पर बुरा असर डालता है।

जो भी व्यक्ति तारीख और समय के साथ गंभीर प्रोग्रामिंग करता है, उसे कम से कम संभावित समस्याओं को समझने और उन्हें कम करने के लिए तैयार रहना चाहिए।

यह दस्तावेज़ इस बात की एक झलक देने की कोशिश करेगा कि Julia तारीख और समय को कैसे संभालती है, लेकिन और जानकारी के लिए manual देखना ज़रूरी होगा। एक Wikibook भी है, जिसकी व्याख्याएँ कुछ पाठकों को ज़्यादा साफ़ लग सकती हैं, और इसमें टाइप हायरार्की का एक उपयोगी diagram भी शामिल है।

Dates मॉड्यूल

ज़्यादातर बुनियादी कार्यक्षमता Dates में है, जो एक मॉड्यूल है और डिफ़ॉल्ट इंस्टॉलेशन में शामिल होता है, लेकिन स्टैंडर्ड लाइब्रेरी का हिस्सा नहीं है।

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

1. import Dates जोड़िए, फिर हर फंक्शन कॉल के आगे Dates. लगाइए।
2. using Dates जोड़िए, जो पूरे मॉड्यूल को मौजूदा नेमस्पेस में ले आता है (कुछ समस्या वाले नामों को छोड़कर)।

# option 1
julia> import Dates

julia> Dates.now()
2025-06-21T16:02:39.080

julia> now()  # wrong: need to include `Dates.` after an import
ERROR: UndefVarError: `now` not defined in `Main`


# option 2
julia> using Dates

julia> now()  # functions are now in the namespace
2025-06-21T16:03:04.161

Dates मॉड्यूल बड़ा और जटिल है, लेकिन यह कार्यक्षमता के चार मुख्य प्रकार देता है:

• Dates.Date, जिसमें दिन-महीना-वर्ष होता है, लेकिन दिन का समय नहीं।
• Dates.Time, जिसमें दिन का समय होता है, लेकिन तारीख नहीं।
• Dates.DateTime, जो तारीख और समय को जोड़ता है।
• Dates.Period, जो समय/तारीख के अंतराल को संभालता है।

ध्यान दीजिए कि DateTime में आम तौर पर टाइम ज़ोन की जानकारी नहीं होती (Python इसे "naive" डेटटाइम कहती है)। एक अपवाद now() है, जो आपकी सिस्टम घड़ी से स्थानीय समय लेता है, और ज़रूरत पड़ने पर इसे UTC में बदल सकता है।

शायद सबसे आम ज़रूरतें ये हैं:

• किसी उपयुक्त इनपुट फॉर्मेट को पार्स करके Dates टाइप बनाना।
• Dates टाइप से ज़रूरी संख्यात्मक या स्ट्रिंग फॉर्मेट निकालना।
• किसी Date, Time या DateTime वैल्यू पर ऑफसेट लगाना।
• ऐसी दो वैल्यू के बीच का अंतराल निकालना।
• मौजूदा तारीख (today() से) और/या समय (now() से) पाना।

तारीख और समय के फॉर्मेट

तारीख और समय लिखने के बहुत से तरीके हैं, जो अक्सर संस्कृति के हिसाब से अलग होते हैं। सिर्फ संख्याओं वाली तारीखें, जैसे "7/6/23", दोअर्थी और उलझाने वाली होती हैं, और बहुराष्ट्रीय संगठनों में इनसे बहुत महँगी गलतियाँ हुई हैं (लेखक यह अपने कड़वे व्यक्तिगत अनुभव से कह रहा है)।

अंतर्राष्ट्रीय मानक ISO 8601 में तय है, और इसके दो मुख्य फ़ायदे हैं:

• पार्स करना तेज़ और स्पष्ट होता है।
• क्रम में लगाना आसान है, क्योंकि डेटटाइम को सामान्य टेक्स्ट की तरह मानकर वर्णमाला क्रम में लगाया जा सकता है।

पिछले उदाहरण में हमने देखा था कि Date.now() ने 2025-06-21T16:03:04.161 लौटाया।

यह कई हिस्सों से बनता है:

• तारीख के हिस्से के लिए YYYY-MM-DD।
• समय के हिस्से के लिए hh:mm:ss।
• और वैकल्पिक रूप से, दशमलव बिंदु के बाद मिलीसेकंड (या उससे भी छोटी इकाई)।

दूसरे स्ट्रिंग फॉर्मेट की चर्चा आगे के किसी भाग में की जाएगी।

Dates

Dates.Date एक अपेक्षाकृत सरल, सिर्फ तारीख वाला टाइप है, जिसे समय या टाइम ज़ोन की कोई समझ नहीं होती।

# constructor with year, month, day arguments
julia> date1 = Date(2025, 06, 23)
2025-06-23

# constructor with ISO 8601 string
julia> date2 = Date("2025-06-23")
2025-06-23

julia> date1 == date2
true

julia> typeof(date1)
Date

तारीख के अलग-अलग हिस्सों के लिए एक्सेसर फंक्शन होते हैं, और ये केस के हिसाब से जोड़ों में आते हैं।

# lowercase returns an integer
julia> month(date1)
6

julia> typeof(month(date1))
Int64

# Propercase returns a Period type
julia> Month(date1)
6 months

julia> typeof(Month(date1))
Month

क्वेरी फंक्शन

कैलेंडर की थोड़ी-बहुत समझ रखने वाले कई फंक्शन हैं। अगला उदाहरण इनमें से कुछ ही दिखाता है।

julia> date1
2025-06-23

julia> dayofweek(date1) # 1 = Monday, 7 = Sunday
1

julia> dayname(date1)
"Monday"

julia> daysinmonth(date1)
30

julia> isleapyear(date1)
false

julia> lastdayofmonth(date1)
2025-06-30

Times

Dates.Time सिर्फ समय वाला बुनियादी टाइप है। इसे तारीख की कोई समझ नहीं होती: आधी रात होते ही समय अपने आप Time(0, 0, 0) पर पलट जाता है।

पूरा कंस्ट्रक्टर फॉर्मेट Time(hour, min, sec, millisec, microsec) है, या उसके बराबर का ISO 8601 फॉर्मेट।

सभी पैरामीटर वैकल्पिक हैं और अपने आप 0 पर सेट हो जाते हैं।

julia> Time(14, 57, 25, 142)
14:57:25.142

julia> Time("14:57:25.142")
14:57:25.142

julia> Time(14, 57, 25, 142, 32)
14:57:25.142032

Date की तरह ही, अलग-अलग हिस्से एक्सेसर फंक्शन से मिल जाते हैं:

julia> minute(t) # => integer
57

julia> Minute(t) # => Period
57 minutes

DateTimes

Dates.DateTime Date और Time टाइप की ज़्यादातर विशेषताओं को जोड़ता है।

julia> dt1 = DateTime(2025, 6, 23, 14, 57, 25, 142)
2025-06-23T14:57:25.142

# date1 and t were defined in previous examples
julia> dt2 = DateTime(date1, t)
2025-06-23T14:57:25.142

वर्ष, महीना और दिन के पैरामीटर अपने आप 1 पर सेट हो जाते हैं, और समय के सारे पैरामीटर 0 पर।

इन सब पैरामीटर को सही क्रम में याद रखना मुश्किल हो सकता है, इसलिए इनपुट के लिए ISO फॉर्मेट बेहतर हो सकता है।

या फिर, ऊपर के उदाहरण की तरह, एक DateTime को Date और Time से बनाया जा सकता है।

Periods

तारीख/समय के हर घटक का अपना Period टाइप होता है, Year से लेकर Nanosecond तक, जो समय के एक अंतराल को दर्शाता है। ये गणना के लिए खास तौर पर उपयोगी हैं।

julia> dt1
2025-06-23T14:57:25.142

julia> Year(21)
21 years

julia> Second(61)
61 seconds

julia> dt1 + Year(21) - Second(61)
2046-06-23T14:56:24.142

julia> Date(2025, 07, 03) - Date(2025, 04, 25)
69 days

Period टाइप के साथ काम करते समय, Julia महीने की लंबाई जैसी कैलेंडर की अनियमितताओं को समझदारी से संभालने की कोशिश करती है, और ज़रूरत पड़ने पर पूर्णांकित कर देती है।

# February has fewer days than January
julia> Date(2025, 1, 31) + Month(1) 
2025-02-28

स्ट्रिंग रूप

हमने पहले ISO 8601 मानक का ज़िक्र किया था, जो स्ट्रिंग को फॉर्मेट या पार्स करते समय Julia का डिफ़ॉल्ट तारीख/समय रूप है।

साफ़ है कि और भी बहुत से फॉर्मेट आम तौर पर इस्तेमाल होते हैं, अक्सर संस्कृति के हिसाब से अलग। इन्हें संभालने के लिए Julia में DateFormat टाइप है, जिसे किसी भी जटिलता की फॉर्मेट स्ट्रिंग से बनाया जा सकता है।

# dateformat"" string syntax
julia> dtfmt = dateformat"d/m/y"
dateformat"d/m/y"

julia> typeof(dtfmt)
DateFormat{Symbol("d/m/y"), Tuple{Dates.DatePart{'d'}, Dates.Delim{Char, 1}, Dates.DatePart{'m'}, Dates.Delim{Char, 1}, Dates.DatePart{'y'}}}

# DateFormat constructor
julia> DateFormat("d/m/y")
dateformat"d/m/y"

ऊपर का उदाहरण बहुत सरल है, यह सिर्फ़ यूरोप में आम दिन/महीना/वर्ष फॉर्मेट की एक तारीख है। सिंटैक्स के दो रूप दिखाए गए हैं, लेकिन नतीजा एक जैसा ही है।

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

julia> DateTime("14/7/2023", dtfmt)
2023-07-14T00:00:00

DateFormat बनाने में काफ़ी ओवरहेड लगता है, इसलिए इस कदम को सिर्फ़ एक बार करना (जैसे यहाँ dtfmt के साथ) कई तारीख/समय स्ट्रिंग पर लूप चलाते समय प्रदर्शन के लिए मददगार होता है।

फॉर्मेट इससे कहीं ज़्यादा जटिल हो सकते हैं, इसलिए जानकारी के लिए manual देखिए।

उसी DateFormat का उपयोग तारीख/समय को किसी भी मनचाहे स्ट्रिंग फॉर्मेट में दिखाने के लिए भी किया जा सकता है, Dates.format() फंक्शन की मदद से।

दुर्भाग्य से, format के साथ नेमस्पेस का टकराव लगता है (कम से कम Julia 1.11.5 तक), इसलिए using Dates के बाद भी Dates. प्रीफ़िक्स लगाना ही ठीक है।

julia> dt1
2025-06-23T14:57:25.142

julia> Dates.format(dt1, dateformat"e, u d")
"Mon, Jun 23"

जैसा documented में लिखा है, "e, u d" सप्ताह के दिन और महीने का संक्षिप्त टेक्स्ट रूप देता है।

टेक्स्ट रूप अपने आप अंग्रेज़ी में आता है। दूसरी भाषाएँ भी जोड़ी जा सकती हैं, हालाँकि इसका समर्थन अभी अपेक्षित स्तर का नहीं है।