यूनिक्स टाइमस्टैम्प कनवर्टर

परिचय

यूनिक्स टाइमस्टैम्प (जिसे POSIX समय या एपोक समय भी कहा जाता है) एक समय बिंदु का वर्णन करने के लिए एक प्रणाली है। यह 1 जनवरी 1970 (मध्यरात्रि UTC/GMT) से बीते हुए सेकंडों की संख्या है, जिसमें लीप सेकंड शामिल नहीं हैं। यूनिक्स टाइमस्टैम्प कंप्यूटर सिस्टम और प्रोग्रामिंग भाषाओं में व्यापक रूप से उपयोग किए जाते हैं क्योंकि वे एक विशिष्ट क्षण का संक्षिप्त, भाषा-स्वतंत्र प्रतिनिधित्व प्रदान करते हैं।

यह टाइमस्टैम्प से तारीख कनवर्टर विभिन्न लंबाई के टाइमस्टैम्प को स्वचालित रूप से पहचानता और संसाधित करता है, जिसमें माइक्रोसेकंड सटीकता (16 अंक), मिलीसेकंड सटीकता (13 अंक), और मानक यूनिक्स टाइमस्टैम्प (10 अंक) शामिल हैं। यह उपकरण इनपुट लंबाई के आधार पर टाइमस्टैम्प प्रारूप की पहचान करता है, इसे मानव-पठनीय तारीख और समय प्रारूप में परिवर्तित करता है, और परिणाम को प्रदर्शित करता है बिना उपयोगकर्ताओं को टाइमस्टैम्प प्रकार निर्दिष्ट करने की आवश्यकता के। यह विभिन्न क्षेत्रीय और व्यक्तिगत प्राथमिकताओं को समायोजित करने के लिए 12-घंटे (AM/PM) और 24-घंटे समय प्रारूप दोनों का समर्थन करता है।

यूनिक्स टाइमस्टैम्प कैसे काम करते हैं

यूनिक्स टाइमस्टैम्प को यूनिक्स एपोक (1 जनवरी 1970, 00:00:00 UTC) से बीते हुए सेकंडों की संख्या के रूप में गणना की जाती है। यह उन्हें समय के अंतर की गणना करने और तिथियों को संक्षिप्त प्रारूप में संग्रहीत करने के लिए विशेष रूप से उपयोगी बनाता है।

यूनिक्स टाइमस्टैम्प से कैलेंडर तारीख में रूपांतरण के लिए कई चरणों की आवश्यकता होती है:

1. यूनिक्स एपोक (1 जनवरी 1970, 00:00:00 UTC) से शुरू करें
2. टाइमस्टैम्प में सेकंडों की संख्या जोड़ें
3. लीप वर्ष, विभिन्न महीने की लंबाई और अन्य कैलेंडर जटिलताओं का ध्यान रखें
4. यदि आवश्यक हो तो समय क्षेत्र समायोजन लागू करें

उदाहरण के लिए, यूनिक्स टाइमस्टैम्प 1609459200 शुक्रवार, 1 जनवरी 2021, 00:00:00 UTC का प्रतिनिधित्व करता है।

रूपांतरण सूत्र को इस प्रकार व्यक्त किया जा सकता है:

$\text{तारीख} = \text{यूनिक्स एपोक} + \text{टाइमस्टैम्प (सेकंड में)}$

अधिकांश प्रोग्रामिंग भाषाएँ और ऑपरेटिंग सिस्टम इस रूपांतरण को संभालने के लिए अंतर्निहित कार्य प्रदान करते हैं, जटिल कैलेंडर गणनाओं को छिपाते हुए।

टाइमस्टैम्प प्रारूप और स्वचालित पहचान

हमारा कनवर्टर तीन सामान्य टाइमस्टैम्प प्रारूपों का समर्थन करता है, जो स्वचालित रूप से अंकों की संख्या के आधार पर पहचाने जाते हैं:

1. मानक यूनिक्स टाइमस्टैम्प (10 अंक): यूनिक्स एपोक से सेकंडों का प्रतिनिधित्व करता है। उदाहरण: 1609459200 (1 जनवरी 2021, 00:00:00 UTC)

2. मिलीसेकंड सटीकता (13 अंक): यूनिक्स एपोक से मिलीसेकंड का प्रतिनिधित्व करता है। उदाहरण: 1609459200000 (1 जनवरी 2021, 00:00:00 UTC)

3. माइक्रोसेकंड सटीकता (16 अंक): यूनिक्स एपोक से माइक्रोसेकंड का प्रतिनिधित्व करता है। उदाहरण: 1609459200000000 (1 जनवरी 2021, 00:00:00 UTC)

स्वचालित पहचान इनपुट की लंबाई का विश्लेषण करके काम करती है:

• यदि इनपुट में 10 अंक हैं, तो इसे मानक यूनिक्स टाइमस्टैम्प (सेकंड) के रूप में माना जाता है
• यदि इनपुट में 13 अंक हैं, तो इसे मिलीसेकंड टाइमस्टैम्प के रूप में माना जाता है
• यदि इनपुट में 16 अंक हैं, तो इसे माइक्रोसेकंड टाइमस्टैम्प के रूप में माना जाता है

यह स्वचालित पहचान उपयोगकर्ताओं को टाइमस्टैम्प प्रकार निर्दिष्ट करने की आवश्यकता को समाप्त करती है, जिससे उपकरण अधिक उपयोगकर्ता-अनुकूल और प्रभावी बनता है।

समय प्रारूप विकल्प

यह कनवर्टर दो समय प्रारूप विकल्प प्रदान करता है:

1. 24-घंटे प्रारूप (जिसे कभी-कभी "सैन्य समय" कहा जाता है): घंटे 0 से 23 के बीच होते हैं, और AM/PM का कोई संकेत नहीं होता है। उदाहरण के लिए, 3:00 PM को 15:00 के रूप में दर्शाया जाता है।

2. 12-घंटे प्रारूप: घंटे 1 से 12 के बीच होते हैं, जिसमें मध्यरात्रि से दोपहर तक के समय के लिए AM (एंटी मेरिडियम) और दोपहर से मध्यरात्रि तक के समय के लिए PM (पोस्ट मेरिडियम) होता है। उदाहरण के लिए, 24-घंटे प्रारूप में 15:00 को 3:00 PM के रूप में दर्शाया जाता है।

इन प्रारूपों के बीच चयन मुख्यतः क्षेत्रीय परंपरा और व्यक्तिगत प्राथमिकता का मामला है:

• 24-घंटे प्रारूप का उपयोग अधिकांश यूरोप, लैटिन अमेरिका, और एशिया में किया जाता है, साथ ही साथ वैज्ञानिक, सैन्य, और चिकित्सा संदर्भों में भी विश्व स्तर पर।
• 12-घंटे प्रारूप का उपयोग संयुक्त राज्य अमेरिका, कनाडा, ऑस्ट्रेलिया, और कुछ अन्य अंग्रेजी बोलने वाले देशों में दैनिक उपयोग के लिए किया जाता है।

किनारे के मामले और सीमाएँ

विभिन्न सटीकताओं के यूनिक्स टाइमस्टैम्प के साथ काम करते समय, कई किनारे के मामलों और सीमाओं के बारे में जागरूक रहना महत्वपूर्ण है:

1. नकारात्मक टाइमस्टैम्प: ये यूनिक्स एपोक (1 जनवरी 1970) से पहले की तारीखों का प्रतिनिधित्व करते हैं। जबकि गणितीय रूप से मान्य हैं, कुछ सिस्टम नकारात्मक टाइमस्टैम्प को सही ढंग से संभाल नहीं सकते। यह सभी तीन टाइमस्टैम्प प्रारूपों पर लागू होता है।

2. 2038 समस्या: मानक यूनिक्स टाइमस्टैम्प (10 अंक) को अक्सर 32-बिट साइन किए गए पूर्णांकों के रूप में संग्रहीत किया जाता है, जो 19 जनवरी 2038 पर ओवरफ्लो होगा। इस बिंदु के बाद, 32-बिट सिस्टम सही समय का प्रतिनिधित्व करने में असमर्थ होंगे जब तक कि उन्हें बड़े पूर्णांक प्रकार का उपयोग करने के लिए संशोधित नहीं किया जाता।

3. सटीकता पर विचार:

   • मानक टाइमस्टैम्प (10 अंक) में सेकंड स्तर की सटीकता होती है, जो अधिकांश दैनिक अनुप्रयोगों के लिए पर्याप्त होती है।
   • मिलीसेकंड टाइमस्टैम्प (13 अंक) अधिक सटीक समय की आवश्यकता वाले अनुप्रयोगों के लिए 1000 गुना अधिक सटीकता प्रदान करते हैं।
   • माइक्रोसेकंड टाइमस्टैम्प (16 अंक) और भी अधिक बारीकी (1,000,000 में से एक सेकंड) प्रदान करते हैं, जो उच्च प्रदर्शन कंप्यूटिंग, वैज्ञानिक अनुप्रयोगों, और कुछ वित्तीय लेनदेन के लिए आवश्यक है।

4. अत्यधिक बड़े टाइमस्टैम्प: बहुत दूर के भविष्य की तारीखें कुछ सिस्टम में प्रतिनिधित्व नहीं की जा सकती हैं, या असंगत रूप से संभाली जा सकती हैं। यह विशेष रूप से मिलीसेकंड और माइक्रोसेकंड टाइमस्टैम्प के लिए प्रासंगिक है, जो बड़े संख्यात्मक मानों का उपयोग करते हैं।

5. लीप सेकंड: यूनिक्स समय लीप सेकंड का ध्यान नहीं रखता है, जो कभी-कभी UTC में पृथ्वी की अनियमित घूर्णन को संतुलित करने के लिए जोड़े जाते हैं। इसका मतलब है कि यूनिक्स समय खगोलीय समय के साथ सटीक रूप से समन्वयित नहीं है।

6. समय क्षेत्र पर विचार: यूनिक्स टाइमस्टैम्प क्षणों को UTC में दर्शाते हैं। स्थानीय समय में परिवर्तित करने के लिए अतिरिक्त समय क्षेत्र की जानकारी की आवश्यकता होती है।

7. डेयलाइट सेविंग टाइम: टाइमस्टैम्प को स्थानीय समय में परिवर्तित करते समय, डेयलाइट सेविंग टाइम संक्रमण की जटिलताओं पर विचार करना आवश्यक है।

8. टाइमस्टैम्प प्रारूप भ्रम: उचित पहचान के बिना, 13-अंक का मिलीसेकंड टाइमस्टैम्प को सेकंड-आधारित टाइमस्टैम्प के रूप में माना जा सकता है, जिससे बहुत दूर के भविष्य की तारीख का गलत व्याख्या हो सकता है। हमारा कनवर्टर इसे अंक की लंबाई के आधार पर स्वचालित रूप से पहचानकर रोकता है।

उपयोग के मामले

विभिन्न सटीकताओं के यूनिक्स टाइमस्टैम्प का उपयोग कंप्यूटिंग और डेटा प्रबंधन के कई अनुप्रयोगों में किया जाता है:

1. डेटाबेस रिकॉर्ड: टाइमस्टैम्प का उपयोग आमतौर पर यह रिकॉर्ड करने के लिए किया जाता है कि प्रविष्टियाँ कब बनाई गईं या संशोधित की गईं।

   • सामान्य डेटाबेस अनुप्रयोगों के लिए मानक टाइमस्टैम्प (10 अंक) अक्सर पर्याप्त होते हैं।
   • मिलीसेकंड टाइमस्टैम्प (13 अंक) का उपयोग तब किया जाता है जब घटनाओं के अधिक सटीक क्रम की आवश्यकता होती है।

2. वेब विकास: HTTP हेडर, कुकीज़, और कैशिंग तंत्र अक्सर यूनिक्स टाइमस्टैम्प का उपयोग करते हैं।

   • जावास्क्रिप्ट का Date.now() मिलीसेकंड टाइमस्टैम्प (13 अंक) लौटाता है।

3. लॉग फ़ाइलें: सिस्टम लॉग आमतौर पर घटनाओं को सटीक कालानुक्रमिक क्रम में रिकॉर्ड करने के लिए यूनिक्स टाइमस्टैम्प के साथ दर्ज की जाती हैं।

   • उच्च-आवृत्ति लॉगिंग सिस्टम मिलीसेकंड या माइक्रोसेकंड सटीकता का उपयोग कर सकते हैं।

4. संस्करण नियंत्रण प्रणाली: Git और अन्य VCS टाइमस्टैम्प का उपयोग करते हैं ताकि यह रिकॉर्ड किया जा सके कि कमिट कब किए गए थे।

5. API प्रतिक्रियाएँ: कई वेब APIs अपनी प्रतिक्रियाओं में टाइमस्टैम्प शामिल करते हैं ताकि यह संकेत दिया जा सके कि डेटा कब उत्पन्न हुआ था या कब संसाधनों को अंतिम बार संशोधित किया गया था।

   • REST APIs अक्सर मिलीसेकंड सटीकता टाइमस्टैम्प का उपयोग करते हैं।

6. फाइल सिस्टम: फ़ाइल निर्माण और संशोधन समय अक्सर यूनिक्स टाइमस्टैम्प के रूप में संग्रहीत होते हैं।

7. सत्र प्रबंधन: वेब अनुप्रयोग टाइमस्टैम्प का उपयोग करते हैं ताकि यह निर्धारित किया जा सके कि उपयोगकर्ता सत्र कब समाप्त होना चाहिए।

8. डेटा विश्लेषण: टाइमस्टैम्प विश्लेषण अनुप्रयोगों में अस्थायी डेटा के साथ काम करने के लिए एक मानकीकृत तरीका प्रदान करते हैं।

9. उच्च-आवृत्ति व्यापार: वित्तीय सिस्टम अक्सर लेनदेन को सटीक रूप से अनुक्रमित करने के लिए माइक्रोसेकंड सटीकता (16 अंक) की आवश्यकता होती है।

10. वैज्ञानिक माप: अनुसंधान उपकरण माइक्रोसेकंड सटीकता के साथ अवलोकनों को रिकॉर्ड कर सकते हैं ताकि सटीक अस्थायी विश्लेषण किया जा सके।

विकल्प

हालांकि यूनिक्स टाइमस्टैम्प व्यापक रूप से उपयोग किए जाते हैं, कुछ संदर्भों में अधिक उपयुक्त समय प्रतिनिधित्व प्रारूप के वैकल्पिक रूप हैं:

1. ISO 8601: एक मानकीकृत स्ट्रिंग प्रारूप (जैसे, "2021-01-01T00:00:00Z") जो मानव-पठनीय है जबकि क्रमबद्धता बनाए रखता है। यह डेटा विनिमय और उपयोगकर्ता-सामना करने वाले अनुप्रयोगों के लिए अक्सर प्राथमिकता दी जाती है।

2. RFC 3339: इंटरनेट प्रोटोकॉल में उपयोग के लिए ISO 8601 का एक प्रोफ़ाइल, जिसमें कड़े प्रारूपण आवश्यकताएँ होती हैं।

3. मानव-पठनीय प्रारूप: स्थानीयकृत तारीख स्ट्रिंग (जैसे, "1 जनवरी 2021") सीधे उपयोगकर्ता इंटरैक्शन के लिए अधिक उपयुक्त होती हैं लेकिन गणना के लिए कम उपयुक्त होती हैं।

4. Microsoft FILETIME: एक 64-बिट मान जो 1 जनवरी 1601 से 100-नैनोसेकंड अंतराल की संख्या का प्रतिनिधित्व करता है, जिसका उपयोग विंडोज सिस्टम में किया जाता है।

5. जूलियन डे नंबर: खगोल विज्ञान और कुछ वैज्ञानिक अनुप्रयोगों में उपयोग किया जाता है, जो 4713 BCE से दिनों की गिनती करता है।

समय प्रारूप के चयन में निम्नलिखित कारक शामिल होते हैं:

• आवश्यक सटीकता
• मानव पठनीयता की आवश्यकताएँ
• भंडारण प्रतिबंध
• मौजूदा सिस्टम के साथ संगतता
• तारीखों की श्रृंखला जो प्रतिनिधित्व की जानी चाहिए

इतिहास

यूनिक्स समय की अवधारणा यूनिक्स ऑपरेटिंग सिस्टम के विकास के साथ उत्पन्न हुई, जो बेल लैब्स में 1960 और 1970 के दशक में विकसित हुई। एपोक के रूप में 1 जनवरी 1970 का चयन कुछ हद तक मनमाना था लेकिन उस समय के लिए व्यावहारिक था—यह रुचि की तारीखों के लिए संग्रहण आवश्यकताओं को कम करने के लिए हाल ही में था लेकिन ऐतिहासिक डेटा के लिए उपयोगी होने के लिए काफी पीछे था।

मूल कार्यान्वयन ने सेकंडों की संख्या को संग्रहीत करने के लिए 32-बिट साइन किए गए पूर्णांक का उपयोग किया, जो उस समय यूनिक्स सिस्टम की अपेक्षित जीवनकाल के लिए पर्याप्त था। हालाँकि, इस निर्णय ने 2038 समस्या को जन्म दिया (कभी-कभी "Y2K38" या "यूनिक्स सहस्त्राब्दी बग" कहा जाता है), क्योंकि 32-बिट साइन किए गए पूर्णांक केवल 19 जनवरी 2038 (03:14:07 UTC) तक की तारीखों का प्रतिनिधित्व कर सकते हैं।

जैसे-जैसे कंप्यूटिंग की आवश्यकताएँ विकसित हुईं, उच्च सटीकता वाले टाइमस्टैम्प की आवश्यकता बढ़ी:

• मिलीसेकंड सटीकता (13 अंक) इंटरैक्टिव कंप्यूटिंग के उदय और उपयोगकर्ता इंटरफेस की प्रतिक्रिया को मापने की आवश्यकता के साथ सामान्य हो गई।

• माइक्रोसेकंड सटीकता (16 अंक) उच्च प्रदर्शन कंप्यूटिंग अनुप्रयोगों और अत्यधिक सटीक समय की आवश्यकता वाले सिस्टम के साथ उभरी।

जैसे-जैसे यूनिक्स और यूनिक्स-जैसे ऑपरेटिंग सिस्टम लोकप्रिय होते गए, यूनिक्स टाइमस्टैम्प कंप्यूटिंग में समय का प्रतिनिधित्व करने के लिए एक मानक बन गया। इसे कई प्रोग्रामिंग भाषाओं, डेटाबेस, और अनुप्रयोगों द्वारा अपनाया गया, जो इसके मूल यूनिक्स वातावरण से बहुत आगे बढ़ गया।

आधुनिक सिस्टम increasingly 64-बिट पूर्णांकों का उपयोग करते हैं, जो एपोक से लगभग 292 बिलियन वर्षों की सीमा में तारीखों का प्रतिनिधित्व करने का विस्तार करते हैं, प्रभावी रूप से 2038 समस्या को हल करते हैं। हालाँकि, विरासत प्रणाली और अनुप्रयोग अभी भी कमजोर हो सकते हैं।

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

कोड उदाहरण

यहाँ विभिन्न प्रोग्रामिंग भाषाओं में विभिन्न सटीकताओं के यूनिक्स टाइमस्टैम्प को मानव-पठनीय तारीखों में परिवर्तित करने के उदाहरण दिए गए हैं:

1// जावास्क्रिप्ट टाइमस्टैम्प रूपांतरण स्वचालित प्रारूप पहचान के साथ
2function convertTimestamp(timestamp, use12Hour = false) {
3  // यदि आवश्यक हो तो संख्या में परिवर्तित करें
4  const numericTimestamp = Number(timestamp);
5  
6  // अंकों की लंबाई के आधार पर टाइमस्टैम्प प्रारूप की पहचान करें
7  let date;
8  if (timestamp.length === 16) {
9    // माइक्रोसेकंड सटीकता (सेकंड प्राप्त करने के लिए 1,000,000 से विभाजित करें)
10    date = new Date(numericTimestamp / 1000);
11    console.log("पहचाना गया: माइक्रोसेकंड सटीकता टाइमस्टैम्प");
12  } else if (timestamp.length === 13) {
13    // मिलीसेकंड सटीकता
14    date = new Date(numericTimestamp);
15    console.log("पहचाना गया: मिलीसेकंड सटीकता टाइमस्टैम्प");
16  } else if (timestamp.length === 10) {
17    // मानक यूनिक्स टाइमस्टैम्प (सेकंड)
18    date = new Date(numericTimestamp * 1000);
19    console.log("पहचाना गया: मानक यूनिक्स टाइमस्टैम्प (सेकंड)");
20  } else {
21    throw new Error("अमान्य टाइमस्टैम्प प्रारूप। 10, 13, या 16 अंकों की अपेक्षा की गई।");
22  }
23  
24  // प्रारूप विकल्प
25  const options = {
26    year: 'numeric',
27    month: 'long',
28    day: 'numeric',
29    weekday: 'long',
30    hour: use12Hour ? 'numeric' : '2-digit',
31    minute: '2-digit',
32    second: '2-digit',
33    hour12: use12Hour
34  };
35  
36  // स्थानीय प्रारूपण का उपयोग करके स्ट्रिंग में परिवर्तित करें
37  return date.toLocaleString(undefined, options);
38}
39
40// उदाहरण उपयोग
41try {
42  // मानक यूनिक्स टाइमस्टैम्प (10 अंक)
43  console.log(convertTimestamp("1609459200", false)); 
44  
45  // मिलीसेकंड सटीकता (13 अंक)
46  console.log(convertTimestamp("1609459200000", false)); 
47  
48  // माइक्रोसेकंड सटीकता (16 अंक)
49  console.log(convertTimestamp("1609459200000000", true)); 
50} catch (error) {
51  console.error(error.message);
52}
53

1# पायथन टाइमस्टैम्प रूपांतरण स्वचालित प्रारूप पहचान के साथ
2import datetime
3
4def convert_timestamp(timestamp, use_12hour=False):
5    # पूर्णांक में परिवर्तित करें
6    timestamp = str(timestamp).strip()
7    numeric_timestamp = int(timestamp)
8    
9    # अंकों की लंबाई के आधार पर टाइमस्टैम्प प्रारूप की पहचान करें
10    if len(timestamp) == 16:
11        # माइक्रोसेकंड सटीकता (सेकंड प्राप्त करने के लिए 1,000,000 से विभाजित करें)
12        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000000)
13        print("पहचाना गया: माइक्रोसेकंड सटीकता टाइमस्टैम्प")
14    elif len(timestamp) == 13:
15        # मिलीसेकंड सटीकता (सेकंड प्राप्त करने के लिए 1,000 से विभाजित करें)
16        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000)
17        print("पहचाना गया: मिलीसेकंड सटीकता टाइमस्टैम्प")
18    elif len(timestamp) == 10:
19        # मानक यूनिक्स टाइमस्टैम्प (सेकंड)
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("पहचाना गया: मानक यूनिक्स टाइमस्टैम्प (सेकंड)")
22    else:
23        raise ValueError("अमान्य टाइमस्टैम्प प्रारूप। 10, 13, या 16 अंकों की अपेक्षा की गई।")
24    
25    # तारीख स्ट्रिंग को प्रारूपित करें
26    if use_12hour:
27        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12-घंटे प्रारूप AM/PM के साथ
28    else:
29        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24-घंटे प्रारूप
30    
31    return date.strftime(format_string)
32
33# उदाहरण उपयोग
34try:
35    # मानक यूनिक्स टाइमस्टैम्प (10 अंक)
36    print(convert_timestamp("1609459200", False))
37    
38    # मिलीसेकंड सटीकता (13 अंक)
39    print(convert_timestamp("1609459200000", False))
40    
41    # माइक्रोसेकंड सटीकता (16 अंक)
42    print(convert_timestamp("1609459200000000", True))
43except ValueError as e:
44    print(e)
45

1<?php
2// PHP टाइमस्टैम्प रूपांतरण स्वचालित प्रारूप पहचान के साथ
3function convertTimestamp($timestamp, $use12Hour = false) {
4    // इनपुट के लिए स्ट्रिंग सुनिश्चित करें
5    $timestamp = trim((string)$timestamp);
6    
7    // अंकों की लंबाई के आधार पर टाइमस्टैम्प प्रारूप की पहचान करें
8    if (strlen($timestamp) === 16) {
9        // माइक्रोसेकंड सटीकता (सेकंड प्राप्त करने के लिए 1,000,000 से विभाजित करें)
10        $seconds = $numericTimestamp / 1000000;
11        echo "पहचाना गया: माइक्रोसेकंड सटीकता टाइमस्टैम्प\n";
12    } elseif (strlen($timestamp) === 13) {
13        // मिलीसेकंड सटीकता
14        $seconds = $numericTimestamp / 1000;
15        echo "पहचाना गया: मिलीसेकंड सटीकता टाइमस्टैम्प\n";
16    } elseif (strlen($timestamp) === 10) {
17        // मानक यूनिक्स टाइमस्टैम्प (सेकंड)
18        $seconds = $numericTimestamp;
19        echo "पहचाना गया: मानक यूनिक्स टाइमस्टैम्प (सेकंड)\n";
20    } else {
21        throw new Exception("अमान्य टाइमस्टैम्प प्रारूप। 10, 13, या 16 अंकों की अपेक्षा की गई।");
22    }
23    
24    // प्रारूप स्ट्रिंग
25    $formatString = $use12Hour 
26        ? 'l, F j, Y g:i:s A'  // 12-घंटे प्रारूप AM/PM के साथ
27        : 'l, F j, Y H:i:s';   // 24-घंटे प्रारूप
28    
29    // तारीख को परिवर्तित और प्रारूपित करें
30    return date($formatString, $seconds);
31}
32
33// उदाहरण उपयोग
34try {
35    // मानक यूनिक्स टाइमस्टैम्प (10 अंक)
36    echo convertTimestamp("1609459200", false) . "\n";
37    
38    // मिलीसेकंड सटीकता (13 अंक)
39    echo convertTimestamp("1609459200000", false) . "\n";
40    
41    // माइक्रोसेकंड सटीकता (16 अंक)
42    echo convertTimestamp("1609459200000000", true) . "\n";
43} catch (Exception $e) {
44    echo $e->getMessage() . "\n";
45}
46?>
47

1// जावा टाइमस्टैम्प रूपांतरण स्वचालित प्रारूप पहचान के साथ
2import java.time.Instant;
3import java.time.LocalDateTime;
4import java.time.ZoneId;
5import java.time.format.DateTimeFormatter;
6
7public class TimestampConverter {
8    public static String convertTimestamp(String timestamp, boolean use12Hour) {
9        // इनपुट को ट्रिम करें
10        timestamp = timestamp.trim();
11        
12        // अंकों की लंबाई के आधार पर टाइमस्टैम्प प्रारूप की पहचान करें
13        LocalDateTime dateTime;
14        if (timestamp.length() == 16) {
15            // माइक्रोसेकंड सटीकता (सेकंड प्राप्त करने के लिए 1,000,000 से विभाजित करें)
16            long microseconds = Long.parseLong(timestamp);
17            Instant instant = Instant.ofEpochSecond(0, microseconds * 1000); // नैनोसेकंड में परिवर्तित करें
18            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
19            System.out.println("पहचाना गया: माइक्रोसेकंड सटीकता टाइमस्टैम्प");
20        } else if (timestamp.length() == 13) {
21            // मिलीसेकंड सटीकता
22            long milliseconds = Long.parseLong(timestamp);
23            Instant instant = Instant.ofEpochMilli(milliseconds);
24            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
25            System.out.println("पहचाना गया: मिलीसेकंड सटीकता टाइमस्टैम्प");
26        } else if (timestamp.length() == 10) {
27            // मानक यूनिक्स टाइमस्टैम्प (सेकंड)
28            long seconds = Long.parseLong(timestamp);
29            Instant instant = Instant.ofEpochSecond(seconds);
30            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
31            System.out.println("पहचाना गया: मानक यूनिक्स टाइमस्टैम्प (सेकंड)");
32        } else {
33            throw new IllegalArgumentException("अमान्य टाइमस्टैम्प प्रारूप। 10, 13, या 16 अंकों की अपेक्षा की गई।");
34        }
35        
36        // प्रारूपक बनाएं जो वांछित प्रारूप के आधार पर हो
37        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
38            use12Hour ? "EEEE, MMMM d, yyyy h:mm:ss a" : "EEEE, MMMM d, yyyy HH:mm:ss"
39        );
40        
41        // तारीख को प्रारूपित करें
42        return dateTime.format(formatter);
43    }
44    
45    public static void main(String[] args) {
46        try {
47            // मानक यूनिक्स टाइमस्टैम्प (10 अंक)
48            System.out.println(convertTimestamp("1609459200", false));
49            
50            // मिलीसेकंड सटीकता (13 अंक)
51            System.out.println(convertTimestamp("1609459200000", false));
52            
53            // माइक्रोसेकंड सटीकता (16 अंक)
54            System.out.println(convertTimestamp("1609459200000000", true));
55        } catch (IllegalArgumentException e) {
56            System.err.println(e.getMessage());
57        }
58    }
59}
60

1// C# टाइमस्टैम्प रूपांतरण स्वचालित प्रारूप पहचान के साथ
2using System;
3
4class TimestampConverter
5{
6    public static string ConvertTimestamp(string timestamp, bool use12Hour)
7    {
8        // इनपुट को ट्रिम करें
9        timestamp = timestamp.Trim();
10        
11        // अंकों की लंबाई के आधार पर टाइमस्टैम्प प्रारूप की पहचान करें
12        DateTime dateTime;
13        if (timestamp.Length == 16)
14        {
15            // माइक्रोसेकंड सटीकता (सेकंड प्राप्त करने के लिए 1,000,000 से विभाजित करें)
16            if (!double.TryParse(timestamp, out double microseconds))
17                throw new ArgumentException("अमान्य टाइमस्टैम्प प्रारूप");
18                
19            // माइक्रोसेकंड को DateTime में परिवर्तित करें
20            dateTime = DateTimeOffset.FromUnixTimeSeconds(0).DateTime.AddSeconds(microseconds / 1000000);
21            Console.WriteLine("पहचाना गया: माइक्रोसेकंड सटीकता टाइमस्टैम्प");
22        }
23        else if (timestamp.Length == 13)
24        {
25            // मिलीसेकंड सटीकता
26            if (!long.TryParse(timestamp, out long milliseconds))
27                throw new ArgumentException("अमान्य टाइमस्टैम्प प्रारूप");
28                
29            dateTime = DateTimeOffset.FromUnixTimeMilliseconds(milliseconds).DateTime;
30            Console.WriteLine("पहचाना गया: मिलीसेकंड सटीकता टाइमस्टैम्प");
31        }
32        else if (timestamp.Length == 10)
33        {
34            // मानक यूनिक्स टाइमस्टैम्प (सेकंड)
35            if (!long.TryParse(timestamp, out long seconds))
36                throw new ArgumentException("अमान्य टाइमस्टैम्प प्रारूप");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("पहचाना गया: मानक यूनिक्स टाइमस्टैम्प (सेकंड)");
40        }
41        else
42        {
43            throw new ArgumentException("अमान्य टाइमस्टैम्प प्रारूप। 10, 13, या 16 अंकों की अपेक्षा की गई।");
44        }
45        
46        // प्रारूप स्ट्रिंग 12-घंटे या 24-घंटे प्राथमिकता के आधार पर
47        string formatString = use12Hour 
48            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12-घंटे प्रारूप AM/PM के साथ
49            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24-घंटे प्रारूप
50        
51        // प्रारूपित तारीख स्ट्रिंग लौटाएँ
52        return dateTime.ToString(formatString);
53    }
54    
55    static void Main()
56    {
57        try
58        {
59            // मानक यूनिक्स टाइमस्टैम्प (10 अंक)
60            Console.WriteLine(ConvertTimestamp("1609459200", false));
61            
62            // मिलीसेकंड सटीकता (13 अंक)
63            Console.WriteLine(ConvertTimestamp("1609459200000", false));
64            
65            // माइक्रोसेकंड सटीकता (16 अंक)
66            Console.WriteLine(ConvertTimestamp("1609459200000000", true));
67        }
68        catch (ArgumentException e)
69        {
70            Console.WriteLine(e.Message);
71        }
72    }
73}
74

किनारे के मामलों को संभालना

विभिन्न सटीकताओं के यूनिक्स टाइमस्टैम्प के साथ काम करते समय, किनारे के मामलों को सही ढंग से संभालना महत्वपूर्ण है। यहाँ एक उदाहरण है जो व्यापक किनारे के मामले संभालने का प्रदर्शन करता है:

1// जावास्क्रिप्ट व्यापक किनारे के मामले संभालना कई टाइमस्टैम्प प्रारूपों के लिए
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // इनपुट सत्यापन
4  if (timestamp === undefined || timestamp === null || timestamp === '') {
5    return "त्रुटि: खाली या अनिर्धारित टाइमस्टैम्प";
6  }
7  
8  // अंकों की लंबाई के लिए स्ट्रिंग सुनिश्चित करें
9  const timestampStr = String(timestamp).trim();
10  
11  // जांचें कि क्या टाइमस्टैम्प में केवल अंक हैं
12  if (!/^\d+$/.test(timestampStr)) {
13    return "त्रुटि: टाइमस्टैम्प में केवल अंक होने चाहिए";
14  }
15  
16  // पहचानें प्रारूप लंबाई के आधार पर
17  let date;
18  try {
19    if (timestampStr.length === 16) {
20      // माइक्रोसेकंड सटीकता
21      const microseconds = Number(timestampStr);
22      date = new Date(microseconds / 1000); // मिलीसेकंड में परिवर्तित करें
23      console.log("माइक्रोसेकंड टाइमस्टैम्प (16 अंक) संसाधित कर रहे हैं");
24      
25      // अमान्य तारीख के लिए जांचें
26      if (isNaN(date.getTime())) {
27        return "त्रुटि: अमान्य माइक्रोसेकंड टाइमस्टैम्प";
28      }
29    } else if (timestampStr.length === 13) {
30      // मिलीसेकंड सटीकता
31      const milliseconds = Number(timestampStr);
32      date = new Date(milliseconds);
33      console.log("मिलीसेकंड टाइमस्टैम्प (13 अंक) संसाधित कर रहे हैं");
34      
35      // अमान्य तारीख के लिए जांचें
36      if (isNaN(date.getTime())) {
37        return "त्रुटि: अमान्य मिलीसेकंड टाइमस्टैम्प";
38      }
39    } else if (timestampStr.length === 10) {
40      // मानक यूनिक्स टाइमस्टैम्प (सेकंड)
41      const seconds = Number(timestampStr);
42      date = new Date(seconds * 1000);
43      console.log("मानक टाइमस्टैम्प (10 अंक) संसाधित कर रहे हैं");
44      
45      // अमान्य तारीख के लिए जांचें
46      if (isNaN(date.getTime())) {
47        return "त्रुटि: अमान्य मानक टाइमस्टैम्प";
48      }
49      
50      // Y2K38 समस्या के लिए जांचें (32-बिट सिस्टम के लिए)
51      const maxInt32 = 2147483647; // 32-बिट साइन किए गए पूर्णांक के लिए अधिकतम मान
52      if (seconds > maxInt32) {
53        console.warn("चेतावनी: टाइमस्टैम्प 32-बिट पूर्णांक सीमा को पार करता है (Y2K38 समस्या)");
54      }
55    } else {
56      return "त्रुटि: अमान्य टाइमस्टैम्प लंबाई। 10, 13, या 16 अंकों की अपेक्षा की गई।";
57    }
58    
59    // तारीख को प्रारूपित करें
60    const options = {
61      year: 'numeric',
62      month: 'long',
63      day: 'numeric',
64      weekday: 'long',
65      hour: use12Hour ? 'numeric' : '2-digit',
66      minute: '2-digit',
67      second: '2-digit',
68      hour12: use12Hour
69    };
70    
71    return date.toLocaleString(undefined, options);
72  } catch (error) {
73    return "टाइमस्टैम्प को परिवर्तित करते समय त्रुटि: " + error.message;
74  }
75}
76
77// विभिन्न किनारे के मामलों के साथ परीक्षण करें
78console.log(safeConvertTimestamp("1609459200"));      // मानक (10 अंक)
79console.log(safeConvertTimestamp("1609459200000"));   // मिलीसेकंड (13 अंक)
80console.log(safeConvertTimestamp("1609459200000000")); // माइक्रोसेकंड (16 अंक)
81console.log(safeConvertTimestamp("abc123"));          // गैर-सांख्यिकीय
82console.log(safeConvertTimestamp("12345"));           // अमान्य लंबाई
83console.log(safeConvertTimestamp("9999999999999999")); // बहुत बड़े माइक्रोसेकंड टाइमस्टैम्प
84console.log(safeConvertTimestamp(""));                // खाली स्ट्रिंग
85

अक्सर पूछे जाने वाले प्रश्न

यूनिक्स टाइमस्टैम्प क्या है?

यूनिक्स टाइमस्टैम्प 1 जनवरी 1970 (मध्यरात्रि UTC/GMT) से बीते हुए सेकंडों की संख्या है, जिसमें लीप सेकंड शामिल नहीं हैं। यह एक विशिष्ट क्षण का प्रतिनिधित्व करने के लिए एक संख्यात्मक प्रणाली प्रदान करता है।

स्वचालित टाइमस्टैम्प प्रारूप पहचान कैसे काम करती है?

कनवर्टर अंकों की संख्या के आधार पर टाइमस्टैम्प प्रारूप की स्वचालित पहचान करता है:

• 10 अंक: मानक यूनिक्स टाइमस्टैम्प (एपोक से सेकंड)
• 13 अंक: मिलीसेकंड सटीकता टाइमस्टैम्प
• 16 अंक: माइक्रोसेकंड सटीकता टाइमस्टैम्प

मुझे मिलीसेकंड या माइक्रोसेकंड सटीकता की आवश्यकता क्यों है?

मिलीसेकंड सटीकता (13 अंक) अधिक सटीक समय की आवश्यकता वाले अनुप्रयोगों के लिए उपयोगी है, जैसे प्रदर्शन निगरानी, उपयोगकर्ता इंटरैक्शन ट्रैकिंग, और कुछ वित्तीय अनुप्रयोग। माइक्रोसेकंड सटीकता (16 अंक) उच्च प्रदर्शन कंप्यूटिंग, वैज्ञानिक अनुप्रयोगों, और उच्च-आवृत्ति व्यापार प्रणालियों के लिए आवश्यक है जहां अत्यधिक सटीक समय महत्वपूर्ण है।

क्या मैं यूनिक्स टाइमस्टैम्प का उपयोग करके 1970 से पहले की तारीखों को परिवर्तित कर सकता हूँ?

हाँ, 1 जनवरी 1970 से पहले की तारीखों का प्रतिनिधित्व नकारात्मक टाइमस्टैम्प के माध्यम से किया जाता है। हालाँकि, कुछ सिस्टम नकारात्मक टाइमस्टैम्प को सही ढंग से संभाल नहीं सकते हैं, इसलिए यदि आपको ऐतिहासिक तारीखों के साथ काम करने की आवश्यकता है तो इस कार्यक्षमता का परीक्षण करना महत्वपूर्ण है।

2038 समस्या क्या है?

2038 समस्या तब होती है जब कई सिस्टम यूनिक्स टाइमस्टैम्प को 32-बिट साइन किए गए पूर्णांकों के रूप में संग्रहीत करते हैं, जो 19 जनवरी 2038 (03:14:07 UTC) तक की तारीखों का प्रतिनिधित्व कर सकते हैं। इस बिंदु के बाद, पूर्णांक ओवरफ्लो हो जाएगा, जिससे सिस्टम विफलता हो सकती है। आधुनिक सिस्टम increasingly 64-बिट पूर्णांकों का उपयोग करते हैं ताकि इस समस्या से बचा जा सके।

क्या मैं यूनिक्स टाइमस्टैम्प के साथ समय क्षेत्र परिवर्तनों को संभाल सकता हूँ?

हाँ, यूनिक्स टाइमस्टैम्प हमेशा UTC (समन्वित सार्वभौमिक समय) में होते हैं। स्थानीय समय में परिवर्तित करने के लिए, आपको तारीख को स्थानीय समय क्षेत्र में परिवर्तित करने के लिए उचित ऑफसेट लागू करने की आवश्यकता होती है। अधिकांश प्रोग्रामिंग भाषाएँ समय क्षेत्र परिवर्तनों को संभालने के लिए अंतर्निहित कार्य प्रदान करती हैं।

यूनिक्स समय और ISO 8601 के बीच क्या अंतर है?

यूनिक्स समय एक संख्यात्मक प्रतिनिधित्व (एपोक से सेकंड) है, जबकि ISO 8601 एक स्ट्रिंग प्रारूप (जैसे, "2021-01-01T00:00:00Z") है। यूनिक्स समय गणनाओं के लिए अधिक संक्षिप्त और उपयोग में आसान है, जबकि ISO 8601 अधिक मानव-पठनीय और आत्म-वर्णनात्मक है।

यूनिक्स टाइमस्टैम्प कितने सटीक हैं?

मानक यूनिक्स टाइमस्टैम्प में सेकंड स्तर की सटीकता होती है। अधिक सटीकता की आवश्यकता वाले अनुप्रयोगों के लिए, मिलीसेकंड टाइमस्टैम्प (13 अंक) 1/1000 सेकंड की सटीकता प्रदान करते हैं, और माइक्रोसेकंड टाइमस्टैम्प (16 अंक) 1/1,000,000 सेकंड की सटीकता प्रदान करते हैं।

क्या यूनिक्स टाइमस्टैम्प लीप सेकंड का ध्यान रखते हैं?

नहीं, यूनिक्स समय को लीप सेकंड का ध्यान नहीं रखा जाता है, जो कभी-कभी UTC में पृथ्वी की अनियमित घूर्णन को संतुलित करने के लिए जोड़े जाते हैं। इसका मतलब है कि यूनिक्स समय खगोलीय समय के साथ सटीक रूप से समन्वयित नहीं है।

क्या मैं भविष्य की घटनाओं के शेड्यूलिंग के लिए यूनिक्स टाइमस्टैम्प का उपयोग कर सकता हूँ?

हाँ, यूनिक्स टाइमस्टैम्प शेड्यूलिंग के लिए व्यापक रूप से उपयोग किए जाते हैं। हालाँकि, बहुत दूर के भविष्य की तारीखों के लिए, 32-बिट सिस्टम के लिए 2038 समस्या और समय क्षेत्र परिवर्तनों और डेयलाइट सेविंग टाइम संक्रमणों को संभालने की जटिलताओं के बारे में जागरूक रहें।

संदर्भ

1. "यूनिक्स समय।" विकिपीडिया, विकिमीडिया फाउंडेशन, https://en.wikipedia.org/wiki/Unix_time

2. "2038 समस्या।" विकिपीडिया, विकिमीडिया फाउंडेशन, https://en.wikipedia.org/wiki/Year_2038_problem

3. ओल्सन, आर्थर डेविड। "कैलेंड्रिकल समय की जटिलताएँ।" द ओपन ग्रुप, https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf

4. "ISO 8601।" विकिपीडिया, विकिमीडिया फाउंडेशन, https://en.wikipedia.org/wiki/ISO_8601

5. "RFC 3339: इंटरनेट पर दिनांक और समय: टाइमस्टैम्प।" इंटरनेट इंजीनियरिंग टास्क फोर्स (IETF), https://tools.ietf.org/html/rfc3339

6. केर्निगन, ब्रायन डब्ल्यू., और डेनिस एम. रिची। "C प्रोग्रामिंग भाषा।" प्रेंटिस हॉल, 1988।

7. "उच्च प्रदर्शन कंप्यूटिंग में सटीक समय।" ACM कंप्यूटिंग सर्वेक्षण, https://dl.acm.org/doi/10.1145/3232678

8. "वित्तीय प्रणालियों में समय प्रतिनिधित्व।" जर्नल ऑफ फाइनेंशियल टेक्नोलॉजी, https://www.fintech-journal.com/time-representation

हमारे टाइमस्टैम्प कनवर्टर का उपयोग करें ताकि आप किसी भी सटीकता के यूनिक्स टाइमस्टैम्प को मानव-पठनीय तारीखों में आसानी से परिवर्तित कर सकें। चाहे आप मानक यूनिक्स टाइमस्टैम्प, मिलीसेकंड सटीकता, या माइक्रोसेकंड सटीकता के साथ काम कर रहे हों, हमारा उपकरण प्रारूप की पहचान स्वचालित रूप से करता है और सटीक रूपांतरण प्रदान करता है।