యూనిక్స్ టైమ్‌స్టాంప్ కన్వర్టర్

పరిచయం

యూనిక్స్ టైమ్‌స్టాంప్ (పోసిక్స్ టైమ్ లేదా ఎపోచ్ టైమ్ అని కూడా పిలుస్తారు) సమయాన్ని వివరిస్తున్న ఒక వ్యవస్థ. ఇది 1970 జనవరి 1 (మధ్యరాత్రి UTC/GMT) నుండి గడిచిన సెకండ్ల సంఖ్య. లీప్ సెకండ్లను లెక్కించకుండా. యూనిక్స్ టైమ్‌స్టాంప్‌లు కంప్యూటర్ సిస్టమ్‌లు మరియు ప్రోగ్రామింగ్ భాషలలో విస్తృతంగా ఉపయోగించబడుతున్నాయి, ఎందుకంటే అవి ఒక నిర్దిష్ట క్షణాన్ని సమయాన్ని సంక్షిప్త, భాషా-స్వతంత్ర ప్రతినిధిగా అందిస్తాయి.

ఈ కన్వర్టర్ మీకు యూనిక్స్ టైమ్‌స్టాంప్‌ను మానవ చదవగల తేదీ మరియు సమయ ఫార్మాట్‌లోకి మార్చడానికి అనుమతిస్తుంది. ఇది 12-గంట (AM/PM) మరియు 24-గంట సమయ ఫార్మాట్‌లను మద్దతు ఇస్తుంది, వివిధ ప్రాంతీయ మరియు వ్యక్తిగత అభిరుచులను పరిగణనలోకి తీసుకుంటుంది.

యూనిక్స్ టైమ్‌స్టాంప్‌లు ఎలా పనిచేస్తాయి

యూనిక్స్ టైమ్‌స్టాంప్‌లు యూనిక్స్ ఎపోచ్ (1970 జనవరి 1, 00:00:00 UTC) నుండి గడిచిన సెకండ్ల సంఖ్యగా లెక్కించబడతాయి. ఇది సమయ వ్యత్యాసాలను లెక్కించడానికి మరియు తేదీలను సంక్షిప్త ఫార్మాట్‌లో నిల్వ చేయడానికి ప్రత్యేకంగా ఉపయోగకరంగా ఉంటుంది.

యూనిక్స్ టైమ్‌స్టాంప్‌ను క్యాలెండర్ తేదీగా మార్చడానికి గణితాత్మక మార్పిడి కొన్ని దశలను కలిగి ఉంటుంది:

1. యూనిక్స్ ఎపోచ్ (1970 జనవరి 1, 00:00:00 UTC) నుండి ప్రారంభించండి
2. టైమ్‌స్టాంప్‌లోని సెకండ్ల సంఖ్యను జోడించండి
3. లీప్ సంవత్సరాలు, మారుతున్న నెలల పొడవులు మరియు ఇతర క్యాలెండర్ సంక్లిష్టతలను పరిగణనలోకి తీసుకోండి
4. అవసరమైతే సమయ మండలాన్ని సర్దుబాటు చేయండి

ఉదాహరణకు, యూనిక్స్ టైమ్‌స్టాంప్ 1609459200 శుక్రవారం, 2021 జనవరి 1, 00:00:00 UTCను సూచిస్తుంది.

మార్పిడి ఫార్ములాను ఈ విధంగా వ్యక్తీకరించవచ్చు:

$\text{తేదీ} = \text{యూనిక్స్ ఎపోచ్} + \text{టైమ్‌స్టాంప్ (సెకండ్లలో)}$

అధిక భాగం ప్రోగ్రామింగ్ భాషలు మరియు ఆపరేటింగ్ సిస్టమ్‌లు ఈ మార్పిడిని నిర్వహించడానికి నిర్మితమైన ఫంక్షన్‌లను అందిస్తాయి, కాంప్లెక్స్ క్యాలెండర్ లెక్కింపులను దాచడం.

సమయ ఫార్మాట్ ఎంపికలు

ఈ కన్వర్టర్ రెండు సమయ ఫార్మాట్ ఎంపికలను అందిస్తుంది:

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. నెగటివ్ టైమ్‌స్టాంప్‌లు: ఇవి యూనిక్స్ ఎపోచ్ (1970 జనవరి 1) కంటే ముందు తేదీలను సూచిస్తాయి. గణితపరంగా చెల్లుబాటు అయ్యే అయినప్పటికీ, కొన్ని వ్యవస్థలు నెగటివ్ టైమ్‌స్టాంప్‌లను సరైనంగా నిర్వహించకపోవచ్చు.

2. 2038 సమస్య: యూనిక్స్ టైమ్‌స్టాంప్‌లు సాధారణంగా 32-బిట్ సంతకం చేసిన పూర్తి సంఖ్యలుగా నిల్వ చేయబడతాయి, ఇది 2038 జనవరి 19న ఓవర్‌ఫ్లో అవుతుంది. ఈ సమయంలో, 32-బిట్ సిస్టమ్‌లు సమయాలను సరిగ్గా సూచించలేవు, కాబట్టి వాటిని పెద్ద సంఖ్యా రకం ఉపయోగించడానికి సవరించాలి.

3. అత్యంత పెద్ద టైమ్‌స్టాంప్‌లు: చాలా దూర భవిష్యత్తు తేదీలు కొన్ని వ్యవస్థలలో సూచించబడకపోవచ్చు లేదా అసమానంగా నిర్వహించబడవచ్చు.

4. లీప్ సెకండ్లు: యూనిక్స్ సమయం, భూమి అసమాన తిరుగుల కోసం సమయాన్ని సరిదిద్దడానికి యూసీటీలో అప్పుడప్పుడు జోడించబడే లీప్ సెకండ్లను పరిగణనలోకి తీసుకోదు. ఇది యూనిక్స్ సమయం ఖగోళ సమయంతో ఖచ్చితంగా సమకాలీకరించబడదు.

5. సమయ మండలాల పరిగణన: యూనిక్స్ టైమ్‌స్టాంప్‌లు కేవలం UTCలో క్షణాలను సూచిస్తాయి. స్థానిక సమయానికి మార్చడం అదనపు సమయ మండల సమాచారాన్ని అవసరం చేస్తుంది.

6. డేలైట్ సేవింగ్ టైమ్: టైమ్‌స్టాంప్‌లను స్థానిక సమయానికి మార్చేటప్పుడు, డేలైట్ సేవింగ్ టైమ్ మార్పుల సంక్లిష్టతలను పరిగణనలోకి తీసుకోవాలి.

ఉపయోగాలు

యూనిక్స్ టైమ్‌స్టాంప్‌లు కంప్యూటింగ్ మరియు డేటా నిర్వహణలో అనేక అనువర్తనాలలో ఉపయోగించబడుతున్నాయి:

1. డేటాబేస్ రికార్డులు: టైమ్‌స్టాంప్‌లు నమోదు లేదా సవరించిన సమయాన్ని నమోదు చేయడానికి సాధారణంగా ఉపయోగించబడతాయి.

2. వెబ్ అభివృద్ధి: HTTP హెడ్డర్లు, కుకీలు మరియు క్యాషింగ్ యంత్రాంగాలు సాధారణంగా యూనిక్స్ టైమ్‌స్టాంప్‌లను ఉపయోగిస్తాయి.

3. లోగ్ ఫైల్స్: సిస్టమ్ లోగ్‌లు సాధారణంగా సంఘటనలను ఖచ్చితమైన క్రమంలో నమోదు చేయడానికి యూనిక్స్ టైమ్‌స్టాంప్‌లను ఉపయోగిస్తాయి.

4. వర్షన్ కంట్రోల్ సిస్టమ్‌లు: గిట్ మరియు ఇతర VCSలు కమిట్‌లు చేసిన సమయాన్ని నమోదు చేయడానికి టైమ్‌స్టాంప్‌లను ఉపయోగిస్తాయి.

5. API సమాధానాలు: అనేక వెబ్ APIలు, డేటా ఉత్పత్తి చేసిన సమయాన్ని లేదా వనరులను చివరిగా సవరించిన సమయాన్ని సూచించడానికి టైమ్‌స్టాంప్‌లను తమ సమాధానాలలో చేర్చుతాయి.

6. ఫైల్ వ్యవస్థలు: ఫైల్ సృష్టి మరియు సవరించిన సమయాలను సాధారణంగా యూనిక్స్ టైమ్‌స్టాంప్‌లుగా నిల్వ చేస్తారు.

7. సెషన్ నిర్వహణ: వెబ్ అనువర్తనాలు వినియోగదారు సెషన్లు ఎప్పుడు ముగియాలో నిర్ణయించడానికి టైమ్‌స్టాంప్‌లను ఉపయోగిస్తాయి.

8. డేటా విశ్లేషణ: టైమ్‌స్టాంప్‌లు విశ్లేషణ అనువర్తనాలలో తాత్కాలిక డేటాతో పనిచేయడానికి ఒక ప్రమాణిత మార్గాన్ని అందిస్తాయి.

ప్రత్యామ్నాయాలు

యూనిక్స్ టైమ్‌స్టాంప్‌లు విస్తృతంగా ఉపయోగించబడుతున్నప్పటికీ, కొన్ని సందర్భాలలో మరింత అనువైన సమయ ప్రతినిధి ఫార్మాట్‌లు ఉన్నాయి:

1. ISO 8601: ఒక ప్రమాణిత స్ట్రింగ్ ఫార్మాట్ (ఉదాహరణకు, "2021-01-01T00:00:00Z") ఇది మానవ చదవగలదిగా ఉండwhile, సర్దుబాటుకు అనుకూలంగా ఉంటుంది. ఇది డేటా మార్పిడి మరియు వినియోగదారుల ముఖాముఖి అనువర్తనాలకు ఎక్కువగా ఇష్టపడుతుంది.

2. RFC 3339: ఇంటర్నెట్ ప్రోటోకాల్‌లలో ఉపయోగించే ISO 8601 యొక్క ఒక ప్రొఫైల్, కఠినమైన ఫార్మాటింగ్ అవసరాలతో.

3. మానవ చదవగల ఫార్మాట్‌లు: స్థానికీకృత తేదీ స్ట్రింగ్స్ (ఉదాహరణకు, "జనవరి 1, 2021") ప్రత్యక్ష వినియోగదారుల పరస్పర చర్యకు ఎక్కువగా అనుకూలంగా ఉంటాయి కానీ లెక్కింపుకు తక్కువ అనుకూలంగా ఉంటాయి.

4. మైక్రోసాఫ్ట్ ఫైల్‌టైమ్: 1601 జనవరి 1 నుండి 100-నానోసెకండ్ అంతరాల సంఖ్యను సూచించే 64-బిట్ విలువ, విండోస్ వ్యవస్థలలో ఉపయోగించబడుతుంది.

5. జూలియన్ డే నంబర్: ఖగోళ శాస్త్రం మరియు కొన్ని శాస్త్రీయ అనువర్తనాలలో ఉపయోగించబడుతుంది, 4713 BCE జనవరి 1 నుండి రోజులను లెక్కించడం.

సమయ ఫార్మాట్ యొక్క ఎంపిక అనేక అంశాలపై ఆధారపడి ఉంటుంది:

• అవసరమైన ఖచ్చితత్వం
• మానవ చదవగల అవసరాలు
• నిల్వ పరిమితులు
• ఉన్న వ్యవస్థలతో అనుకూలత
• సూచించాల్సిన తేదీల పరిధి

చరిత్ర

యూనిక్స్ సమయానికి సంబంధించి భావన యూనిక్స్ ఆపరేటింగ్ సిస్టమ్ యొక్క అభివృద్ధితో ప్రారంభమైంది, ఇది 1960ల చివర మరియు 1970ల ప్రారంభంలో బెల్ లాబ్స్‌లో జరిగింది. ఎపోచ్‌గా 1970 జనవరి 1ను ఉపయోగించాలనే నిర్ణయం కొంతవరకు యాదృచ్ఛికంగా కానీ ఆ సమయంలో ప్రాక్టికల్‌గా ఉంది—ఇది ఆసక్తికరమైన తేదీల కోసం నిల్వ అవసరాలను తగ్గించడానికి తక్కువగా ఉండేది కానీ చరిత్రాత్మక డేటా కోసం ఉపయోగకరంగా ఉండేది.

మూల అమలు 32-బిట్ సంతకం చేసిన పూర్తి సంఖ్యను ఉపయోగించి సమయాన్ని నిల్వ చేయడానికి ఉపయోగించబడింది, ఇది ఆ సమయంలో యూనిక్స్ వ్యవస్థల జీవితకాలం కోసం సరిపోతుంది. అయితే, ఈ నిర్ణయం 2038 సంవత్సరానికి సంబంధించిన సమస్యకు (కొన్నిసార్లు "Y2K38" లేదా "యూనిక్స్ మిలేనియం బగ్" అని పిలుస్తారు) దారితీసింది, ఎందుకంటే 32-బిట్ సంతకం చేసిన పూర్తి సంఖ్యలు 1970-01-01 నుండి 03:14:07 UTC వరకు సమయాలను మాత్రమే సూచించగలవు.

యూనిక్స్ మరియు యూనిక్స్-సमान ఆపరేటింగ్ సిస్టమ్‌లు ప్రాచుర్యం పొందినప్పుడు, యూనిక్స్ టైమ్‌స్టాంప్ కంప్యూటింగ్‌లో సమయాన్ని సూచించడానికి ఒక డి ఫాక్టో ప్రమాణంగా మారింది. ఇది అనేక ప్రోగ్రామింగ్ భాషలు, డేటాబేస్‌లు మరియు అనువర్తనాల ద్వారా స్వీకరించబడింది, దీని మూల యూనిక్స్ వాతావరణానికి మించిపోయింది.

ఆధునిక వ్యవస్థలు increasingly 64-బిట్ పూర్తి సంఖ్యలను టైమ్‌స్టాంప్‌ల కోసం ఉపయోగిస్తాయి, ఇది ఎపోచ్ నుండి 292 బిలియన్ సంవత్సరాల వరకు ప్రతినిధి పరిధిని విస్తరించడానికి సహాయపడుతుంది, ఇది 2038 సమస్యను సమర్థవంతంగా పరిష్కరిస్తుంది. అయితే, వారసత్వ వ్యవస్థలు మరియు అనువర్తనాలు ఇంకా ప్రమాదంలో ఉండవచ్చు.

యూనిక్స్ టైమ్‌స్టాంప్ యొక్క సరళత మరియు ఉపయోగకరత దీని కొనసాగుతున్న ప్రాముఖ్యతను నిర్ధారించింది, మరింత అభివృద్ధి చెందిన సమయ ప్రతినిధి ఫార్మాట్‌ల అభివృద్ధికి మించినది. ఇది కంప్యూటింగ్‌లో ఒక ప్రాథమిక భావనగా మిగిలి ఉంది, మన డిజిటల్ మౌలిక వసతులలో చాలా భాగాన్ని మద్దతు ఇస్తుంది.

కోడ్ ఉదాహరణలు

ఇక్కడ వివిధ ప్రోగ్రామింగ్ భాషలలో యూనిక్స్ టైమ్‌స్టాంప్‌లను మానవ చదవగల తేదీలకు మార్చడానికి ఎలా చేయాలో ఉదాహరణలు ఉన్నాయి:

1// జావాస్క్రిప్ట్ టైమ్‌స్టాంప్ మార్పిడి
2function convertUnixTimestamp(timestamp, use12Hour = false) {
3  // కొత్త తేదీ వస్తువును సృష్టించండి (జావాస్క్రిప్ట్ మిల్లీసెకండ్లను ఉపయోగిస్తుంది)
4  const date = new Date(timestamp * 1000);
5  
6  // ఫార్మాట్ ఎంపికలు
7  const options = {
8    year: 'numeric',
9    month: 'long',
10    day: 'numeric',
11    weekday: 'long',
12    hour: use12Hour ? 'numeric' : '2-digit',
13    minute: '2-digit',
14    second: '2-digit',
15    hour12: use12Hour
16  };
17  
18  // స్థానిక ఫార్మాటింగ్‌ను ఉపయోగించి స్ట్రింగ్‌కు మార్చండి
19  return date.toLocaleString(undefined, options);
20}
21
22// ఉదాహరణ వినియోగం
23const timestamp = 1609459200; // 2021 జనవరి 1 00:00:00 UTC
24console.log(convertUnixTimestamp(timestamp, false)); // 24-గంట ఫార్మాట్
25console.log(convertUnixTimestamp(timestamp, true));  // 12-గంట ఫార్మాట్
26

1# పాథాన్ టైమ్‌స్టాంప్ మార్పిడి
2import datetime
3
4def convert_unix_timestamp(timestamp, use_12hour=False):
5    # యూనిక్స్ టైమ్‌స్టాంప్‌ను తేదీ సమయ వస్తువుగా మార్చండి
6    date = datetime.datetime.fromtimestamp(timestamp)
7    
8    # తేదీ స్ట్రింగ్‌ను ఫార్మాట్ చేయండి
9    if use_12hour:
10        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12-గంట ఫార్మాట్ AM/PMతో
11    else:
12        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24-గంట ఫార్మాట్
13    
14    return date.strftime(format_string)
15
16# ఉదాహరణ వినియోగం
17timestamp = 1609459200  # 2021 జనవరి 1 00:00:00 UTC
18print(convert_unix_timestamp(timestamp, False))  # 24-గంట ఫార్మాట్
19print(convert_unix_timestamp(timestamp, True))   # 12-గంట ఫార్మాట్
20

1<?php
2// PHP టైమ్‌స్టాంప్ మార్పిడి
3function convertUnixTimestamp($timestamp, $use12Hour = false) {
4    // ఫార్మాట్ స్ట్రింగ్
5    $formatString = $use12Hour 
6        ? 'l, F j, Y g:i:s A'  // 12-గంట ఫార్మాట్ AM/PMతో
7        : 'l, F j, Y H:i:s';   // 24-గంట ఫార్మాట్
8    
9    // తేదీని మార్చండి మరియు ఫార్మాట్ చేయండి
10    return date($formatString, $timestamp);
11}
12
13// ఉదాహరణ వినియోగం
14$timestamp = 1609459200; // 2021 జనవరి 1 00:00:00 UTC
15echo convertUnixTimestamp($timestamp, false) . "\n"; // 24-గంట ఫార్మాట్
16echo convertUnixTimestamp($timestamp, true) . "\n";  // 12-గంట ఫార్మాట్
17?>
18

1// జావా టైమ్‌స్టాంప్ మార్పిడి
2import java.time.Instant;
3import java.time.LocalDateTime;
4import java.time.ZoneId;
5import java.time.format.DateTimeFormatter;
6
7public class UnixTimestampConverter {
8    public static String convertUnixTimestamp(long timestamp, boolean use12Hour) {
9        // యూనిక్స్ టైమ్‌స్టాంప్‌ను ఇన్స్టంట్‌గా మార్చండి, తరువాత స్థానిక తేదీ సమయంగా మార్చండి
10        Instant instant = Instant.ofEpochSecond(timestamp);
11        LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
12        
13        // కావలసిన ఫార్మాట్ ఆధారంగా ఫార్మాటర్‌ను సృష్టించండి
14        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
15            use12Hour ? "EEEE, MMMM d, yyyy h:mm:ss a" : "EEEE, MMMM d, yyyy HH:mm:ss"
16        );
17        
18        // తేదీని ఫార్మాట్ చేయండి
19        return dateTime.format(formatter);
20    }
21    
22    public static void main(String[] args) {
23        long timestamp = 1609459200; // 2021 జనవరి 1 00:00:00 UTC
24        System.out.println(convertUnixTimestamp(timestamp, false)); // 24-గంట ఫార్మాట్
25        System.out.println(convertUnixTimestamp(timestamp, true));  // 12-గంట ఫార్మాట్
26    }
27}
28

1// C# టైమ్‌స్టాంప్ మార్పిడి
2using System;
3
4class UnixTimestampConverter
5{
6    public static string ConvertUnixTimestamp(long timestamp, bool use12Hour)
7    {
8        // యూనిక్స్ టైమ్‌స్టాంప్‌ను తేదీ సమయంగా మార్చండి
9        // యూనిక్స్ టైమ్‌స్టాంప్‌లు 1970-01-01 నుండి సెకండ్లుగా ఉంటాయి
10        DateTime dateTime = DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
11        
12        // 12-గంట లేదా 24-గంట అభిరుచిని ఆధారంగా ఫార్మాట్ స్ట్రింగ్
13        string formatString = use12Hour 
14            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12-గంట ఫార్మాట్ AM/PMతో
15            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24-గంట ఫార్మాట్
16        
17        // ఫార్మాట్ చేయబడిన తేదీ స్ట్రింగ్‌ను తిరిగి ఇవ్వండి
18        return dateTime.ToString(formatString);
19    }
20    
21    static void Main()
22    {
23        long timestamp = 1609459200; // 2021 జనవరి 1 00:00:00 UTC
24        Console.WriteLine(ConvertUnixTimestamp(timestamp, false)); // 24-గంట ఫార్మాట్
25        Console.WriteLine(ConvertUnixTimestamp(timestamp, true));  // 12-గంట ఫార్మాట్
26    }
27}
28

1# రూబీ టైమ్‌స్టాంప్ మార్పిడి
2require 'time'
3
4def convert_unix_timestamp(timestamp, use_12hour = false)
5  # యూనిక్స్ టైమ్‌స్టాంప్‌ను టైమ్ వస్తువుగా మార్చండి
6  time = Time.at(timestamp)
7  
8  # 12-గంట లేదా 24-గంట అభిరుచిని ఆధారంగా ఫార్మాట్
9  if use_12hour
10    time.strftime("%A, %B %d, %Y %I:%M:%S %p")  # 12-గంట ఫార్మాట్ AM/PMతో
11  else
12    time.strftime("%A, %B %d, %Y %H:%M:%S")     # 24-గంట ఫార్మాట్
13  end
14end
15
16# ఉదాహరణ వినియోగం
17timestamp = 1609459200  # 2021 జనవరి 1 00:00:00 UTC
18puts convert_unix_timestamp(timestamp, false)  # 24-గంట ఫార్మాట్
19puts convert_unix_timestamp(timestamp, true)   # 12-గంట ఫార్మాట్
20

1// గో టైమ్‌స్టాంప్ మార్పిడి
2package main
3
4import (
5    "fmt"
6    "time"
7)
8
9func convertUnixTimestamp(timestamp int64, use12Hour bool) string {
10    // యూనిక్స్ టైమ్‌స్టాంప్‌ను టైమ్‌గా మార్చండి
11    t := time.Unix(timestamp, 0)
12    
13    // 12-గంట లేదా 24-గంట అభిరుచిని ఆధారంగా ఫార్మాట్ స్ట్రింగ్
14    formatString := "Monday, January 2, 2006 "
15    if use12Hour {
16        formatString += "3:04:05 PM"  // 12-గంట ఫార్మాట్ AM/PMతో
17    } else {
18        formatString += "15:04:05"    // 24-గంట ఫార్మాట్
19    }
20    
21    // ఫార్మాట్ చేయబడిన సమయాన్ని తిరిగి ఇవ్వండి
22    return t.Format(formatString)
23}
24
25func main() {
26    timestamp := int64(1609459200) // 2021 జనవరి 1 00:00:00 UTC
27    fmt.Println(convertUnixTimestamp(timestamp, false)) // 24-గంట ఫార్మాట్
28    fmt.Println(convertUnixTimestamp(timestamp, true))  // 12-గంట ఫార్మాట్
29}
30

1// స్విఫ్ట్ టైమ్‌స్టాంప్ మార్పిడి
2import Foundation
3
4func convertUnixTimestamp(_ timestamp: Int, use12Hour: Bool) -> String {
5    // యూనిక్స్ టైమ్‌స్టాంప్‌ను తేదీగా మార్చండి
6    let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
7    
8    // తేదీ ఫార్మాటర్‌ను సృష్టించండి
9    let formatter = DateFormatter()
10    formatter.dateStyle = .full
11    
12    // 12-గంట లేదా 24-గంట అభిరుచిని ఆధారంగా సమయ శైలిని సెట్ చేయండి
13    if use12Hour {
14        formatter.timeStyle = .medium
15        formatter.amSymbol = "AM"
16        formatter.pmSymbol = "PM"
17    } else {
18        formatter.timeStyle = .medium
19        formatter.dateFormat = formatter.dateFormat?.replacingOccurrences(of: "h:mm:ss a", with: "HH:mm:ss")
20    }
21    
22    // ఫార్మాట్ చేయబడిన తేదీని తిరిగి ఇవ్వండి
23    return formatter.string(from: date)
24}
25
26// ఉదాహరణ వినియోగం
27let timestamp = 1609459200 // 2021 జనవరి 1 00:00:00 UTC
28print(convertUnixTimestamp(timestamp, use12Hour: false)) // 24-గంట ఫార్మాట్
29print(convertUnixTimestamp(timestamp, use12Hour: true))  // 12-గంట ఫార్మాట్
30

1# R టైమ్‌స్టాంప్ మార్పిడి
2convert_unix_timestamp <- function(timestamp, use_12hour = FALSE) {
3  # యూనిక్స్ టైమ్‌స్టాంప్‌ను POSIXct తేదీ సమయంగా మార్చండి
4  date_time <- as.POSIXct(timestamp, origin = "1970-01-01", tz = "UTC")
5  
6  # 12-గంట లేదా 24-గంట అభిరుచిని ఆధారంగా ఫార్మాట్
7  if (use_12hour) {
8    format_string <- "%A, %B %d, %Y %I:%M:%S %p"  # 12-గంట ఫార్మాట్ AM/PMతో
9  } else {
10    format_string <- "%A, %B %d, %Y %H:%M:%S"     # 24-గంట ఫార్మాట్
11  }
12  
13  # ఫార్మాట్ చేయబడిన తేదీ స్ట్రింగ్‌ను తిరిగి ఇవ్వండి
14  format(date_time, format_string)
15}
16
17# ఉదాహరణ వినియోగం
18timestamp <- 1609459200  # 2021 జనవరి 1 00:00:00 UTC
19cat(convert_unix_timestamp(timestamp, FALSE), "\n")  # 24-గంట ఫార్మాట్
20cat(convert_unix_timestamp(timestamp, TRUE), "\n")   # 12-గంట ఫార్మాట్
21

1% MATLAB టైమ్‌స్టాంప్ మార్పిడి
2function formattedDate = convertUnixTimestamp(timestamp, use12Hour)
3    % యూనిక్స్ టైమ్‌స్టాంప్‌ను MATLAB తేదీ/సమయంగా మార్చండి
4    % MATLAB తేదీలు 1900-01-01 నుండి రోజులు, 1 = 1900-01-01
5    % యూనిక్స్ టైమ్‌స్టాంప్‌లు 1970-01-01 నుండి సెకండ్లుగా ఉంటాయి
6    
7    % మొదట Excel తేదీ ఫార్మాట్‌కు మార్చండి
8    % 25569 అనేది 1900-01-01 మరియు 1970-01-01 మధ్య రోజుల సంఖ్య
9    excelDate = (timestamp / 86400) + 25569;
10    
11    % 12-గంట లేదా 24-గంట అభిరుచిని ఆధారంగా ఫార్మాట్ స్ట్రింగ్
12    if use12Hour
13        formattedDate = datestr(excelDate, 'dddd, mmmm dd, yyyy h:mm:ss AM/PM');
14    else
15        formattedDate = datestr(excelDate, 'dddd, mmmm dd, yyyy hh:mm:ss');
16    end
17end
18
19% వర్క్షీట్‌లో వినియోగం:
20% =ConvertUnixTimestamp(1609459200, TRUE)  ' 12-గంట ఫార్మాట్
21% =ConvertUnixTimestamp(1609459200, FALSE) ' 24-గంట ఫార్మాట్
22

ఎడ్జ్ కేసులను నిర్వహించడం

యూనిక్స్ టైమ్‌స్టాంప్‌లతో పని చేస్తున్నప్పుడు, ఎడ్జ్ కేసులను సరిగ్గా నిర్వహించడం ముఖ్యమైనది. కొన్ని సాధారణ ఎడ్జ్ కేసులను నిర్వహించడానికి ఉదాహరణలు ఇక్కడ ఉన్నాయి:

1// జావాస్క్రిప్ట్ ఎడ్జ్ కేసుల నిర్వహణ
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // టైమ్‌స్టాంప్ చెల్లుబాటు అయ్యిందా అని తనిఖీ చేయండి
4  if (timestamp === undefined || timestamp === null || isNaN(timestamp)) {
5    return "చెల్లని టైమ్‌స్టాంప్";
6  }
7  
8  // నెగటివ్ టైమ్‌స్టాంప్‌లను తనిఖీ చేయండి (1970 కంటే ముందు తేదీలు)
9  if (timestamp < 0) {
10    // కొన్ని బ్రౌజర్లు నెగటివ్ టైమ్‌స్టాంప్‌లను సరైనంగా నిర్వహించకపోవచ్చు
11    // 1970 కంటే ముందు తేదీలకు మరింత బలమైన విధానం ఉపయోగించండి
12    const date = new Date(timestamp * 1000);
13    if (isNaN(date.getTime())) {
14      return "చెల్లని తేదీ (1970 కంటే ముందు)";
15    }
16  }
17  
18  // Y2K38 సమస్యను తనిఖీ చేయండి (32-బిట్ వ్యవస్థల కోసం)
19  const maxInt32 = 2147483647; // 32-బిట్ సంతకం చేసిన పూర్తి సంఖ్యకు గరిష్ట విలువ
20  if (timestamp > maxInt32) {
21    // ఆధునిక జావాస్క్రిప్ట్‌లో చాలా పెద్ద టైమ్‌స్టాంప్‌ల కోసం BigInt ఉపయోగించడానికి పరిగణించండి
22    console.warn("టైమ్‌స్టాంప్ 32-బిట్ పూర్తి సంఖ్య పరిమితిని మించిపోతుంది (Y2K38 సమస్య)");
23  }
24  
25  // సాధారణ మార్పిడితో కొనసాగండి
26  try {
27    const date = new Date(timestamp * 1000);
28    const options = {
29      year: 'numeric',
30      month: 'long',
31      day: 'numeric',
32      weekday: 'long',
33      hour: use12Hour ? 'numeric' : '2-digit',
34      minute: '2-digit',
35      second: '2-digit',
36      hour12: use12Hour
37    };
38    return date.toLocaleString(undefined, options);
39  } catch (error) {
40    return "టైమ్‌స్టాంప్‌ను మార్చడంలో లోపం: " + error.message;
41  }
42}
43

సూచనలు

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.