युनिक्स टाइमस्टॅम्प कन्व्हर्टर

परिचय

युनिक्स टाइमस्टॅम्प (ज्याला POSIX वेळ किंवा Epoch वेळ असेही म्हणतात) हा वेळेच्या एका बिंदूचे वर्णन करण्यासाठीचा एक प्रणाली आहे. हे 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 अंक) 1000x अधिक अचूकता प्रदान करते, जी अधिक अचूक वेळ मोजणी आवश्यक असलेल्या अनुप्रयोगांसाठी उपयुक्त आहे.
   • मायक्रोसेकंद टाइमस्टॅम्प (16 अंक) अगदी सूक्ष्म अचूकता (1,000,000 व्या भागाचे एक सेकंद) प्रदान करते, जे उच्च कार्यप्रदर्शन संगणन, वैज्ञानिक अनुप्रयोग, आणि काही आर्थिक व्यवहारांसाठी आवश्यक आहे.

4. अतिशय मोठे टाइमस्टॅम्प: खूप दूरच्या भविष्याच्या तारखा काही प्रणालींमध्ये प्रतिनिधित्व करण्यायोग्य नसू शकतात, किंवा असंगतपणे हाताळल्या जाऊ शकतात. हे विशेषतः मिलिसेकंद आणि मायक्रोसेकंद टाइमस्टॅम्पसाठी लागू आहे, जे मोठ्या संख्यात्मक मूल्यांचा वापर करतात.

5. उडीचे सेकंद: युनिक्स वेळ उडीच्या सेकंदांचे लक्षात घेत नाही, जे UTC मध्ये पृथ्वीच्या असमान फिरण्याच्या भरपाईसाठी कधी कधी जोडले जातात. याचा अर्थ युनिक्स वेळ खगोलीय वेळेशी अचूकपणे समन्वयित केलेले नाही.

6. टाइमझोन विचार: युनिक्स टाइमस्टॅम्प नेहमी UTC मध्ये असतात. स्थानिक वेळेत रूपांतरित करण्यासाठी अतिरिक्त टाइमझोन माहिती आवश्यक आहे.

7. डेयलाईट सेव्हिंग टाइम: टाइमस्टॅम्प्स स्थानिक वेळेत रूपांतरित करताना, डेयलाईट सेव्हिंग टाइम संक्रमणांच्या जटिलतांचे लक्षात घेणे आवश्यक आहे.

8. टाइमस्टॅम्प स्वरूप गोंधळ: योग्य ओळख न करता, 13 अंकांचा मिलिसेकंद टाइमस्टॅम्प सेकंद आधारित टाइमस्टॅम्प म्हणून विचारल्यास खूप दूरच्या भविष्याच्या तारखेचे प्रतिनिधित्व म्हणून चूक होऊ शकतो. आमचा कन्व्हर्टर अंकांच्या लांबीच्या आधारे स्वरूप स्वयंचलितपणे ओळखून यापासून वाचवतो.

वापर प्रकरणे

विविध अचूकतेच्या युनिक्स टाइमस्टॅम्प संगणक आणि डेटा व्यवस्थापनातील अनेक अनुप्रयोगांमध्ये वापरले जातात:

1. डेटाबेस रेकॉर्ड: टाइमस्टॅम्प सामान्यतः नोंदी कधी तयार किंवा सुधारित केल्या गेल्या हे नोंदवण्यासाठी वापरले जातात.

   • मानक टाइमस्टॅम्प (10 अंक) सामान्य डेटाबेस अनुप्रयोगांसाठी सामान्यतः पुरेसे असतात.
   • मिलिसेकंद टाइमस्टॅम्प (13 अंक) जेव्हा अधिक अचूक घटनांचे क्रम आवश्यक असते तेव्हा वापरले जातात.

2. वेब विकास: HTTP हेडर, कुकीज, आणि कॅशिंग यांमध्ये युनिक्स टाइमस्टॅम्पचा वापर सामान्यतः केला जातो.

   • JavaScript चा Date.now() मिलिसेकंद टाइमस्टॅम्प (13 अंक) परत करतो.

3. लॉग फाइल्स: प्रणाली लॉग सामान्यतः घटनांचे अचूक कालक्रमानुसार नोंदवण्यासाठी युनिक्स टाइमस्टॅम्पसह नोंदवले जातात.

   • उच्च-आवृत्ती लॉगिंग प्रणालींमध्ये मिलिसेकंद किंवा मायक्रोसेकंद अचूकता वापरली जाऊ शकते.

4. आवृत्ती नियंत्रण प्रणाली: Git आणि इतर VCS टाइमस्टॅम्प वापरतात जेव्हा कमिट्स केल्या गेल्या.

5. API प्रतिसाद: अनेक वेब API त्यांच्या प्रतिसादांमध्ये टाइमस्टॅम्प समाविष्ट करतात जेव्हा डेटा निर्माण केला जातो किंवा संसाधने शेवटच्या वेळी सुधारित केल्या जातात.

   • REST API सहसा मिलिसेकंद अचूकता टाइमस्टॅम्प वापरतात.

6. फाईल प्रणाली: फाईल तयार करणे आणि सुधारित करण्याच्या वेळा युनिक्स टाइमस्टॅम्प म्हणून सामान्यतः साठवले जातात.

7. सत्र व्यवस्थापन: वेब अनुप्रयोग टाइमस्टॅम्प वापरतात जेव्हा वापरकर्ता सत्रे संपुष्टात येऊ शकतात.

8. डेटा विश्लेषण: टाइमस्टॅम्प विश्लेषण अनुप्रयोगांमध्ये वेळेच्या डेटासह कार्य करण्यासाठी एक मानकित मार्ग प्रदान करतात.

9. उच्च-आवृत्ती व्यापार: आर्थिक प्रणालींना व्यवहारांचे अचूक अनुक्रमण करण्यासाठी मायक्रोसेकंद अचूकता (16 अंक) आवश्यक असते.

10. वैज्ञानिक मोजमाप: संशोधन उपकरणे अचूक कालगणना करण्यासाठी मायक्रोसेकंद अचूकतेसह निरीक्षणे नोंदवू शकतात.

पर्याय

युनिक्स टाइमस्टॅम्प मोठ्या प्रमाणावर वापरले जातात, परंतु काही संदर्भांमध्ये अधिक योग्य असलेल्या पर्यायी वेळ प्रतिनिधित्व स्वरूप आहेत:

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

2. RFC 3339: इंटरनेट प्रोटोकॉलमध्ये वापरलेले ISO 8601 चे एक प्रोफाइल, अधिक कठोर स्वरूपन आवश्यकतांसह.

3. मानव-वाचनायोग्य स्वरूप: स्थानिकृत दिनांक स्ट्रिंग (उदा., "1 जानेवारी 2021") थेट वापरकर्ता संवादासाठी अधिक योग्य आहे, परंतु गणनेसाठी कमी योग्य आहे.

4. मायक्रोसॉफ्ट FILETIME: 64-बिट मूल्य, जे 1 जानेवारी 1601 पासून 100-नॅनोसेकंदांच्या अंतरांची संख्या दर्शवते, विंडोज प्रणालींमध्ये वापरले जाते.

5. जुलियन दिवस संख्या: खगोलशास्त्र आणि काही वैज्ञानिक अनुप्रयोगांमध्ये वापरले जाते, जे 4713 BCE पासूनच्या दिवसांची गणना करते.

वेळ स्वरूपाची निवड अनेक घटकांवर अवलंबून असते:

• आवश्यक अचूकता
• मानव वाचनायोग्यतेची आवश्यकता
• साठवण क्षमता
• विद्यमान प्रणालींसह सुसंगतता
• प्रतिनिधित्व करण्याच्या आवश्यक तारखांची श्रेणी

इतिहास

युनिक्स वेळेची संकल्पना युनिक्स ऑपरेटिंग सिस्टमच्या विकासासह बेल लॅब्समध्ये 1960 च्या दशकाच्या उत्तरार्धात आणि 1970 च्या दशकाच्या सुरुवातीस सुरू झाली. एपोक म्हणून 1 जानेवारी 1970 निवडणे काहीसे अनियोजित होते, परंतु त्या वेळेस व्यावहारिक होते—हे लक्षात घेण्यासारखे होते की ते लक्षात ठेवण्यासाठी पुरेसे जवळचे होते, परंतु ऐतिहासिक डेटासाठी उपयुक्त असण्यासाठी पुरेसे लांब होते.

मूळ कार्यान्वयनाने सेकंदांच्या संख्येसाठी 32-बिट साइन केलेला पूर्णांक वापरला, जो त्या वेळेस युनिक्स प्रणालींच्या अपेक्षित आयुष्यासाठी पुरेसा होता. तथापि, या निर्णयामुळे वर्ष 2038 समस्या झाली (कधी कधी "Y2K38" किंवा "युनिक्स सहस्त्रक बग" असेही म्हणतात), कारण 32-बिट साइन केलेले पूर्णांक 19 जानेवारी 2038 (03:14:07 UTC) पर्यंतच्या तारखांचे प्रतिनिधित्व करू शकतात.

जसे संगणकीय आवश्यकता विकसित झाल्या, उच्च अचूकतेच्या टाइमस्टॅम्पची आवश्यकता निर्माण झाली:

• मिलिसेकंदाची अचूकता (13 अंक) संवादात्मक संगणनाच्या वाढीसह सामान्य झाली आणि वापरकर्ता इंटरफेसच्या प्रतिसादाची मोजणी करण्याची आवश्यकता निर्माण झाली.

• मायक्रोसेकंदाची अचूकता (16 अंक) उच्च कार्यप्रदर्शन संगणन अनुप्रयोगांसह आणि अत्यंत अचूक वेळ मोजणी आवश्यक असलेल्या प्रणालींमध्ये उदयास आली.

युनिक्स आणि युनिक्स-आधारित ऑपरेटिंग सिस्टमच्या लोकप्रियतेसह, युनिक्स टाइमस्टॅम्प संगणकांमध्ये वेळ दर्शविण्यासाठी एक अनिवार्य मानक बनले. हे अनेक प्रोग्रामिंग भाषांमध्ये, डेटाबेसमध्ये, आणि अनुप्रयोगांमध्ये स्वीकारले गेले, जे त्यांच्या मूळ युनिक्स वातावरणाच्या पलीकडे विस्तारले.

आधुनिक प्रणालींमध्ये टाइमस्टॅम्पसाठी 64-बिट पूर्णांकांचा वापर वाढत आहे, जो एपोकच्या आसपासच्या 292 अब्ज वर्षांचे प्रतिनिधित्व करण्यास सक्षम आहे, ज्यामुळे वर्ष 2038 समस्येचे निराकरण होते. तथापि, वारसा प्रणालींमध्ये आणि अनुप्रयोगांमध्ये अद्याप असुरक्षितता असू शकते.

युनिक्स टाइमस्टॅम्पची साधेपणा आणि उपयोगिता यामुळे त्याची प्रासंगिकता कायम राहिली आहे, अधिक प्रगत वेळ प्रतिनिधित्व स्वरूपांच्या विकासासह. हे संगणकांमध्ये एक मूलभूत संकल्पना म्हणून राहते, ज्यामुळे आमच्या डिजिटल पायाभूत सुविधांचे मूलभूत आधार तयार होते.

कोड उदाहरणे

येथे विविध प्रोग्रामिंग भाषांमध्ये विविध अचूकतेच्या युनिक्स टाइमस्टॅम्प्सना मानव वाचनायोग्य तारखांमध्ये रूपांतरित करण्याचे उदाहरणे आहेत:

1// JavaScript टाइमस्टॅम्प रूपांतरण स्वयंचलित स्वरूप ओळखीसह
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# Python टाइमस्टॅम्प रूपांतरण स्वयंचलित स्वरूप ओळखीसह
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        // मिलिसेकंदाची अचूकता (सेकंद मिळविण्यासाठी 1,000 ने विभागा)
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// Java टाइमस्टॅम्प रूपांतरण स्वयंचलित स्वरूप ओळखीसह
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// JavaScript व्यापक काठावरच्या प्रकरणांचे हाताळणे अनेक टाइमस्टॅम्प स्वरूपांसाठी
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) पर्यंतच्या तारखांचे प्रतिनिधित्व करू शकतात. या बिंदूच्या नंतर, पूर्णांक ओव्हरफ्लो होईल, संभाव्यतः प्रणालीच्या अपयशास कारणीभूत होईल. आधुनिक प्रणालींमध्ये या समस्येपासून वाचण्यासाठी 64-बिट पूर्णांकांचा वापर वाढत आहे.

मी युनिक्स टाइमस्टॅम्पसह टाइमझोन रूपांतरण कसे हाताळू?

युनिक्स टाइमस्टॅम्प नेहमी UTC (सहयोगी सार्वत्रिक वेळ) मध्ये असतात. स्थानिक वेळेत रूपांतरित करण्यासाठी, टाइमस्टॅम्पला तारखेत रूपांतरित केल्यानंतर योग्य ऑफसेट लागू करणे आवश्यक आहे. बहुतेक प्रोग्रामिंग भाषांमध्ये टाइमझोन रूपांतरण हाताळण्यासाठी अंतर्निहित कार्ये उपलब्ध आहेत.

युनिक्स वेळ आणि ISO 8601 यामध्ये काय फरक आहे?

युनिक्स वेळ एक संख्यात्मक प्रतिनिधित्व आहे (एपोकपासून सेकंद), तर ISO 8601 एक स्ट्रिंग स्वरूप आहे (उदा., "2021-01-01T00:00:00Z"). युनिक्स वेळ गणनांसाठी अधिक संक्षिप्त आणि वापरण्यास सोपी आहे, तर ISO 8601 अधिक मानव वाचनायोग्य आणि स्व-संकेतकारी आहे.

युनिक्स टाइमस्टॅम्प किती अचूक आहेत?

मानक युनिक्स टाइमस्टॅम्प सेकंद स्तराची अचूकता आहे. अधिक अचूकतेची आवश्यकता असलेल्या अनुप्रयोगांसाठी, मिलिसेकंद टाइमस्टॅम्प (13 अंक) 1/1000 सेकंदाची अचूकता प्रदान करते, आणि मायक्रोसेकंद टाइमस्टॅम्प (16 अंक) 1/1,000,000 सेकंदाची अचूकता प्रदान करते.

युनिक्स टाइमस्टॅम्प उडीच्या सेकंदांचे लक्षात घेतात का?

नाही, युनिक्स वेळ उडीच्या सेकंदांचे लक्षात घेत नाही, जे UTC मध्ये पृथ्वीच्या असमान फिरण्याच्या भरपाईसाठी कधी कधी जोडले जातात. याचा अर्थ युनिक्स वेळ खगोलीय वेळेशी अचूकपणे समन्वयित केलेले नाही.

मी युनिक्स टाइमस्टॅम्पचा वापर भविष्याच्या घटनांचे वेळापत्रक बनवण्यासाठी करू शकतो का?

होय, युनिक्स टाइमस्टॅम्प वेळापत्रकासाठी मोठ्या प्रमाणावर वापरले जातात. तथापि, खूप दूरच्या भविष्याच्या तारखांसाठी, वर्ष 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. कर्निगन, ब्रायन W., आणि डेनिस M. रिची. "C प्रोग्रामिंग भाषा." प्रेंटिस हॉल, 1988.

7. "उच्च-कार्यप्रदर्शन संगणनातील अचूक वेळ." ACM संगणक सर्वेक्षण, https://dl.acm.org/doi/10.1145/3232678

8. "आर्थिक प्रणालींमध्ये वेळ प्रतिनिधित्व." वित्तीय तंत्रज्ञान जर्नल, https://www.fintech-journal.com/time-representation

आमच्या टाइमस्टॅम्प कन्व्हर्टरचा वापर करून आता युनिक्स टाइमस्टॅम्प्सना मानव वाचनायोग्य तारखांमध्ये सहजपणे रूपांतरित करा. आपण मानक युनिक्स टाइमस्टॅम्प, मिलिसेकंदाची अचूकता, किंवा मायक्रोसेकंदाची अचूकता वापरत असाल तरी, आमचे टूल स्वरूप स्वयंचलितपणे ओळखते आणि अचूक रूपांतरण प्रदान करते.