Unix Timestamp Converter

Introduction

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

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

How Unix Timestamps Work

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

Unix timestamp से कैलेंडर तिथि में परिवर्तन करने के लिए गणितीय रूपांतरण में कई चरण शामिल होते हैं:

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

उदाहरण के लिए, Unix timestamp 1609459200 शुक्रवार, 1 जनवरी 2021, 00:00:00 UTC का प्रतिनिधित्व करता है।

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

$\text{Date} = \text{Unix Epoch} + \text{Timestamp (in seconds)}$

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

Timestamp Formats and Automatic Detection

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

1. मानक Unix Timestamp (10 अंक): Unix Epoch के बाद से सेकंड का प्रतिनिधित्व करता है। उदाहरण: 1609459200 (1 जनवरी 2021, 00:00:00 UTC)

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

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

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

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

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

Time Format Options

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

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

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

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

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

Edge Cases and Limitations

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

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

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

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

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

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

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

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

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

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

Use Cases

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

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

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

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

   • JavaScript की Date.now() मिलीसेकंड timestamps (13 अंक) लौटाती है।

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

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

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

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

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

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

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

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

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

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

Alternatives

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

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

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

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

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

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

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

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

History

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

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

जैसे-जैसे कंप्यूटिंग की आवश्यकताएँ विकसित हुईं, उच्च सटीकता timestamps की आवश्यकता अधिक हो गई:

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

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

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

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

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

Code Examples

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

1// JavaScript timestamp conversion with automatic format detection
2function convertTimestamp(timestamp, use12Hour = false) {
3  // Convert string to number if needed
4  const numericTimestamp = Number(timestamp);
5  
6  // Detect timestamp format based on digit length
7  let date;
8  if (timestamp.length === 16) {
9    // Microsecond precision (divide by 1,000,000 to get seconds)
10    date = new Date(numericTimestamp / 1000);
11    console.log("Detected: Microsecond precision timestamp");
12  } else if (timestamp.length === 13) {
13    // Millisecond precision
14    date = new Date(numericTimestamp);
15    console.log("Detected: Millisecond precision timestamp");
16  } else if (timestamp.length === 10) {
17    // Standard Unix timestamp (seconds)
18    date = new Date(numericTimestamp * 1000);
19    console.log("Detected: Standard Unix timestamp (seconds)");
20  } else {
21    throw new Error("Invalid timestamp format. Expected 10, 13, or 16 digits.");
22  }
23  
24  // Format options
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  // Convert to string using locale formatting
37  return date.toLocaleString(undefined, options);
38}
39
40// Example usage
41try {
42  // Standard Unix timestamp (10 digits)
43  console.log(convertTimestamp("1609459200", false)); 
44  
45  // Millisecond precision (13 digits)
46  console.log(convertTimestamp("1609459200000", false)); 
47  
48  // Microsecond precision (16 digits)
49  console.log(convertTimestamp("1609459200000000", true)); 
50} catch (error) {
51  console.error(error.message);
52}
53

1# Python timestamp conversion with automatic format detection
2import datetime
3
4def convert_timestamp(timestamp, use_12hour=False):
5    # Convert to integer
6    timestamp = str(timestamp).strip()
7    numeric_timestamp = int(timestamp)
8    
9    # Detect timestamp format based on digit length
10    if len(timestamp) == 16:
11        # Microsecond precision (divide by 1,000,000 to get seconds)
12        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000000)
13        print("Detected: Microsecond precision timestamp")
14    elif len(timestamp) == 13:
15        # Millisecond precision (divide by 1,000 to get seconds)
16        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000)
17        print("Detected: Millisecond precision timestamp")
18    elif len(timestamp) == 10:
19        # Standard Unix timestamp (seconds)
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("Detected: Standard Unix timestamp (seconds)")
22    else:
23        raise ValueError("Invalid timestamp format. Expected 10, 13, or 16 digits.")
24    
25    # Format the date string
26    if use_12hour:
27        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12-hour format with AM/PM
28    else:
29        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24-hour format
30    
31    return date.strftime(format_string)
32
33# Example usage
34try:
35    # Standard Unix timestamp (10 digits)
36    print(convert_timestamp("1609459200", False))
37    
38    # Millisecond precision (13 digits)
39    print(convert_timestamp("1609459200000", False))
40    
41    # Microsecond precision (16 digits)
42    print(convert_timestamp("1609459200000000", True))
43except ValueError as e:
44    print(e)
45

1<?php
2// PHP timestamp conversion with automatic format detection
3function convertTimestamp($timestamp, $use12Hour = false) {
4    // Ensure timestamp is a string for length checking
5    $timestamp = trim((string)$timestamp);
6    
7    // Detect timestamp format based on digit length
8    if (strlen($timestamp) === 16) {
9        // Microsecond precision (divide by 1,000,000 to get seconds)
10        $seconds = $numericTimestamp / 1000000;
11        echo "Detected: Microsecond precision timestamp\n";
12    } elseif (strlen($timestamp) === 13) {
13        // Millisecond precision (divide by 1,000 to get seconds)
14        $seconds = $numericTimestamp / 1000;
15        echo "Detected: Millisecond precision timestamp\n";
16    } elseif (strlen($timestamp) === 10) {
17        // Standard Unix timestamp (seconds)
18        $seconds = $numericTimestamp;
19        echo "Detected: Standard Unix timestamp (seconds)\n";
20    } else {
21        throw new Exception("Invalid timestamp format. Expected 10, 13, or 16 digits.");
22    }
23    
24    // Format string
25    $formatString = $use12Hour 
26        ? 'l, F j, Y g:i:s A'  // 12-hour format with AM/PM
27        : 'l, F j, Y H:i:s';   // 24-hour format
28    
29    // Convert and format the date
30    return date($formatString, $seconds);
31}
32
33// Example usage
34try {
35    // Standard Unix timestamp (10 digits)
36    echo convertTimestamp("1609459200", false) . "\n";
37    
38    // Millisecond precision (13 digits)
39    echo convertTimestamp("1609459200000", false) . "\n";
40    
41    // Microsecond precision (16 digits)
42    echo convertTimestamp("1609459200000000", true) . "\n";
43} catch (Exception $e) {
44    echo $e->getMessage() . "\n";
45}
46?>
47

1// Java timestamp conversion with automatic format detection
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        // Trim the input
10        timestamp = timestamp.trim();
11        
12        // Detect timestamp format based on digit length
13        LocalDateTime dateTime;
14        if (timestamp.length() == 16) {
15            // Microsecond precision (divide by 1,000,000 to get seconds)
16            long microseconds = Long.parseLong(timestamp);
17            Instant instant = Instant.ofEpochSecond(0, microseconds * 1000); // Convert to nanoseconds
18            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
19            System.out.println("Detected: Microsecond precision timestamp");
20        } else if (timestamp.length() == 13) {
21            // Millisecond precision
22            long milliseconds = Long.parseLong(timestamp);
23            Instant instant = Instant.ofEpochMilli(milliseconds);
24            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
25            System.out.println("Detected: Millisecond precision timestamp");
26        } else if (timestamp.length() == 10) {
27            // Standard Unix timestamp (seconds)
28            long seconds = Long.parseLong(timestamp);
29            Instant instant = Instant.ofEpochSecond(seconds);
30            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
31            System.out.println("Detected: Standard Unix timestamp (seconds)");
32        } else {
33            throw new IllegalArgumentException("Invalid timestamp format. Expected 10, 13, or 16 digits.");
34        }
35        
36        // Create formatter based on desired format
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        // Format the date
42        return dateTime.format(formatter);
43    }
44    
45    public static void main(String[] args) {
46        try {
47            // Standard Unix timestamp (10 digits)
48            System.out.println(convertTimestamp("1609459200", false));
49            
50            // Millisecond precision (13 digits)
51            System.out.println(convertTimestamp("1609459200000", false));
52            
53            // Microsecond precision (16 digits)
54            System.out.println(convertTimestamp("1609459200000000", true));
55        } catch (IllegalArgumentException e) {
56            System.err.println(e.getMessage());
57        }
58    }
59}
60

1// C# timestamp conversion with automatic format detection
2using System;
3
4class TimestampConverter
5{
6    public static string ConvertTimestamp(string timestamp, bool use12Hour)
7    {
8        // Trim the input
9        timestamp = timestamp.Trim();
10        
11        // Detect timestamp format based on digit length
12        DateTime dateTime;
13        if (timestamp.Length == 16)
14        {
15            // Microsecond precision (divide by 1,000,000 to get seconds)
16            if (!double.TryParse(timestamp, out double microseconds))
17                throw new ArgumentException("Invalid timestamp format");
18                
19            // Convert microseconds to DateTime
20            dateTime = DateTimeOffset.FromUnixTimeSeconds(0).DateTime.AddSeconds(microseconds / 1000000);
21            Console.WriteLine("Detected: Microsecond precision timestamp");
22        }
23        else if (timestamp.Length == 13)
24        {
25            // Millisecond precision
26            if (!long.TryParse(timestamp, out long milliseconds))
27                throw new ArgumentException("Invalid timestamp format");
28                
29            dateTime = DateTimeOffset.FromUnixTimeMilliseconds(milliseconds).DateTime;
30            Console.WriteLine("Detected: Millisecond precision timestamp");
31        }
32        else if (timestamp.Length == 10)
33        {
34            // Standard Unix timestamp (seconds)
35            if (!long.TryParse(timestamp, out long seconds))
36                throw new ArgumentException("Invalid timestamp format");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("Detected: Standard Unix timestamp (seconds)");
40        }
41        else
42        {
43            throw new ArgumentException("Invalid timestamp format. Expected 10, 13, or 16 digits.");
44        }
45        
46        // Format string based on 12-hour or 24-hour preference
47        string formatString = use12Hour 
48            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12-hour format with AM/PM
49            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24-hour format
50        
51        // Return formatted date string
52        return dateTime.ToString(formatString);
53    }
54    
55    static void Main()
56    {
57        try
58        {
59            // Standard Unix timestamp (10 digits)
60            Console.WriteLine(ConvertTimestamp("1609459200", false));
61            
62            // Millisecond precision (13 digits)
63            Console.WriteLine(ConvertTimestamp("1609459200000", false));
64            
65            // Microsecond precision (16 digits)
66            Console.WriteLine(ConvertTimestamp("1609459200000000", true));
67        }
68        catch (ArgumentException e)
69        {
70            Console.WriteLine(e.Message);
71        }
72    }
73}
74

Handling Edge Cases

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

1// JavaScript comprehensive edge case handling for multiple timestamp formats
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // Input validation
4  if (timestamp === undefined || timestamp === null || timestamp === '') {
5    return "Error: Empty or undefined timestamp";
6  }
7  
8  // Ensure timestamp is a string for length checking
9  const timestampStr = String(timestamp).trim();
10  
11  // Check if timestamp contains only digits
12  if (!/^\d+$/.test(timestampStr)) {
13    return "Error: Timestamp must contain only digits";
14  }
15  
16  // Detect format based on length
17  let date;
18  try {
19    if (timestampStr.length === 16) {
20      // Microsecond precision
21      const microseconds = Number(timestampStr);
22      date = new Date(microseconds / 1000); // Convert to milliseconds
23      console.log("Processing microsecond timestamp (16 digits)");
24      
25      // Check for invalid date
26      if (isNaN(date.getTime())) {
27        return "Error: Invalid microsecond timestamp";
28      }
29    } else if (timestampStr.length === 13) {
30      // Millisecond precision
31      const milliseconds = Number(timestampStr);
32      date = new Date(milliseconds);
33      console.log("Processing millisecond timestamp (13 digits)");
34      
35      // Check for invalid date
36      if (isNaN(date.getTime())) {
37        return "Error: Invalid millisecond timestamp";
38      }
39    } else if (timestampStr.length === 10) {
40      // Standard Unix timestamp (seconds)
41      const seconds = Number(timestampStr);
42      date = new Date(seconds * 1000);
43      console.log("Processing standard timestamp (10 digits)");
44      
45      // Check for invalid date
46      if (isNaN(date.getTime())) {
47        return "Error: Invalid standard timestamp";
48      }
49      
50      // Check for Y2K38 problem (for 32-bit systems)
51      const maxInt32 = 2147483647; // Maximum value for 32-bit signed integer
52      if (seconds > maxInt32) {
53        console.warn("Warning: Timestamp exceeds 32-bit integer limit (Y2K38 issue)");
54      }
55    } else {
56      return "Error: Invalid timestamp length. Expected 10, 13, or 16 digits.";
57    }
58    
59    // Format the date
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 converting timestamp: " + error.message;
74  }
75}
76
77// Test with various edge cases
78console.log(safeConvertTimestamp("1609459200"));      // Standard (10 digits)
79console.log(safeConvertTimestamp("1609459200000"));   // Milliseconds (13 digits)
80console.log(safeConvertTimestamp("1609459200000000")); // Microseconds (16 digits)
81console.log(safeConvertTimestamp("abc123"));          // Non-numeric
82console.log(safeConvertTimestamp("12345"));           // Invalid length
83console.log(safeConvertTimestamp("9999999999999999")); // Very large microsecond timestamp
84console.log(safeConvertTimestamp(""));                // Empty string
85

Frequently Asked Questions

What is a Unix timestamp?

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

How does the automatic timestamp format detection work?

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

• 10 अंक: मानक Unix timestamp (युग के बाद सेकंड)
• 13 अंक: मिलीसेकंड सटीकता timestamp
• 16 अंक: माइक्रोसेकंड सटीकता timestamp

Why would I need millisecond or microsecond precision?

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

Can I convert dates before 1970 using Unix timestamps?

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

What is the Year 2038 problem?

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

How do I handle timezone conversions with Unix timestamps?

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

What's the difference between Unix time and ISO 8601?

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

How accurate are Unix timestamps?

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

Do Unix timestamps account for leap seconds?

नहीं, Unix समय को लीप सेकंड का ध्यान नहीं है, जो कभी-कभी UTC में जोड़े जाते हैं। इसका मतलब है कि लीप सेकंड के दौरान, Unix timestamp नहीं बढ़ता है। इससे उन अनुप्रयोगों में समस्याएँ हो सकती हैं जिनमें खगोलीय समय की सटीकता की आवश्यकता होती है।

Can I use Unix timestamps for scheduling future events?

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

References

1. "Unix Time." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Unix_time

2. "Year 2038 Problem." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Year_2038_problem

3. Olson, Arthur David. "The Complexities of Calendrical Time." The Open Group, https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf

4. "ISO 8601." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/ISO_8601

5. "RFC 3339: Date and Time on the Internet: Timestamps." Internet Engineering Task Force (IETF), https://tools.ietf.org/html/rfc3339

6. Kernighan, Brian W., and Dennis M. Ritchie. "The C Programming Language." Prentice Hall, 1988.

7. "Precision Timing in High-Performance Computing." ACM Computing Surveys, https://dl.acm.org/doi/10.1145/3232678

8. "Time Representation in Financial Systems." Journal of Financial Technology, https://www.fintech-journal.com/time-representation

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