Epoch టైమ్ కన్వర్టర్

Unix టైమ్‌స్టాంప్‌లను UTC తేదీలుగా లేదా తేదీని epoch సెకన్లుగా మార్చండి.

టైమ్‌స్టాంప్‌ను తేదీగా లేదా తేదీని టైమ్‌స్టాంప్‌గా మార్చాలా అని ఎంచుకోండి.
Unix టైమ్‌స్టాంప్‌ను సెకన్లలో నమోదు చేయండి.

మార్చబడిన విలువ

2024-03-09T16:00:00.000Z

UTC విలువ2024-03-09T16:00:00.000Z
Unix మిల్లీసెకన్లు17,10,00,00,00,000
వారంలోని రోజుశనివారం
సూత్రం సూత్రం అంచనాలు 4 ఉదాహరణ ఉదాహరణ మూలాలు 2 చివరిగా నవీకరించబడింది 10, మార్చి 2026
భవిష్యత్తులో ఏదైనా ఫీచర్ ప్రత్యేకంగా చెబితే తప్ప, ఇన్‌పుట్‌లు బ్రౌజర్‌లోనే ఉంటాయి. దీనిని అంచనాగా మాత్రమే ఉపయోగించండి మరియు ముఖ్యమైన నిర్ణయాలను అర్హత కలిగిన నిపుణుడితో ధృవీకరించుకోండి.

ఈ epoch టైమ్ కన్వర్టర్‌ను ఎలా ఉపయోగించాలి

  1. కన్వర్షన్ మోడ్‌ను ఎంచుకోండి

    కన్వర్షన్ మోడ్ ఫీల్డ్‌లో Epoch to date లేదా Date to epoch ఎంచుకోండి.

  2. Epoch నుండి తేదీకి

    Epoch timestamp (seconds) ఫీల్డ్‌లో Unix టైమ్‌స్టాంప్‌ను సెకన్లలో నమోదు చేయండి.

  3. తేదీ నుండి epoch కి

    Calendar dateలో తేదీని ఎంచుకోండి, ఆపై అవసరానికి అనుగుణంగా Hour (UTC), Minute (UTC), మరియు Second (UTC) సెట్ చేయండి.

  4. ఫలితాన్ని చదవండి

    ఈ క్యాలిక్యులేటర్ UTC విలువ, Unix మిల్లీసెకన్లు మరియు వారంలోని రోజును చూపుతుంది.

పద్ధతి

ఈ epoch సమయ కన్వర్టర్ ఎలా పనిచేస్తుంది

ఈ epoch సమయ కన్వర్టర్ Unix టైమ్‌స్టాంప్‌లు మరియు మానవులు చదవగలిగే UTC తేదీల మధ్య మారుస్తుంది. Unix సమయం — దీనిని POSIX సమయం లేదా epoch సమయం అని కూడా పిలుస్తారు — జనవరి 1, 1970 (1970-01-01T00:00:00Z) అర్ధరాత్రి UTC నుండి గడిచిన సెకన్ల సంఖ్యను గణిస్తుంది. డేటాబేస్‌లు, APIలు, లాగ్ ఫైల్‌లు, JWT టోకెన్‌లు మరియు దాదాపు ప్రతి ఆధునిక ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో టైమ్‌స్టాంప్‌లను నిల్వ చేయడానికి మరియు ప్రసారం చేయడానికి ఈ సింగిల్-ఇంటిజర్ ప్రాతినిధ్యం ప్రామాణికం. ఈ కన్వర్టర్ రెండు దిశలలో పనిచేస్తుంది: సంఖ్యాపరమైన టైమ్‌స్టాంప్‌ను నమోదు చేస్తే దానికి సంబంధించిన UTC తేదీ, వారంలోని రోజు మరియు మిల్లీసెకన్ల విలువను ఇస్తుంది, అదే క్యాలెండర్ తేదీ మరియు సమయాన్ని నమోదు చేస్తే సెకన్లు మరియు మిల్లీసెకన్లలో epoch విలువను ఇస్తుంది.

సూత్రం
Unix సమయం = 1970-01-01T00:00:00Z నుండి గడిచిన సెకన్లు
epoch సూచన పాయింట్: జనవరి 1, 1970 అర్ధరాత్రి UTC (Unix టైమ్‌స్టాంప్ 0)
Unix సమయం (సెకన్లు) ఎపోక్ (epoch) నుండి నిర్దిష్ట తేదీ మరియు సమయం వరకు ఉన్న మొత్తం సెకన్లు
Unix సమయం (మిల్లీసెకన్లు) 1,000 తో గుణించబడిన సెకన్లలో Unix సమయం — JavaScript Date, Java System.currentTimeMillis(), మరియు అనేక APIల ద్వారా ఉపయోగించబడుతుంది
UTC తేదీ ఇచ్చిన టైమ్‌స్టాంప్‌కు అనుగుణంగా ఉండే గ్రెగోరియన్ క్యాలెండర్ తేదీ మరియు 24-గంటల సమయం
వారంలోని రోజు మార్చబడిన UTC తేదీ నుండి పొందిన వారపు పేరు
ఉదాహరణ

Unix టైమ్‌స్టాంప్ 1,700,000,000ని తేదీగా మార్చడానికి: 1970-01-01 00:00:00 UTC నుండి ప్రారంభించి, 1,700,000,000 సెకన్లను జోడించండి. ఇది 19,675 రోజులు, 22 గంటలు, 13 నిమిషాలు మరియు 20 సెకన్లకు సమానం. ఫలితంగా వచ్చే UTC తేదీ 2023-11-14న 22:13:20 UTC, ఇది మంగళవారం వస్తుంది. మిల్లీసెకన్ల సమానమైన విలువ 1,700,000,000,000. దీనికి విరుద్ధంగా, నవంబర్ 14, 2023న 22:13:20 UTCని నమోదు చేస్తే సరిగ్గా 1,700,000,000 ఎపోక్ విలువ వస్తుంది.

టైమ్‌స్టాంప్ 0 అనేది 1970-01-01 00:00:00 UTC (గురువారం)గా మారుతుంది. దీనికి సమానమైన మిల్లీసెకన్ల విలువ 0.

టైమ్‌స్టాంప్ 1,704,000,000 అనేది 2023-12-31 05:20:00 UTC (ఆదివారం)గా మారుతుంది. టైమ్‌స్టాంప్ 1,704,024,000 అనేది 2023-12-31 12:00:00 UTC (ఆదివారం)గా మారుతుంది.

అంచనాలు
  • ✓ అన్ని లెక్కలు UTCలో ఉన్నాయి. స్థానిక సమయ మార్పిడికి మార్పిడి తర్వాత తగిన టైమ్-జోన్ ఆఫ్‌సెట్‌ను వర్తింపజేయాలి.
  • ✓ లీపు సెకన్లు లెక్కించబడవు. POSIX వలె, ఈ కన్వర్టర్ ప్రతి రోజును సరిగ్గా 86,400 సెకన్లుగా పరిగణిస్తుంది, ఇది చాలా ప్రోగ్రామింగ్ భాషలు మరియు ఆపరేటింగ్ సిస్టమ్‌ల ప్రవర్తనతో సరిపోలుతుంది.
  • ✓ ప్రతికూల టైమ్‌స్టాంప్‌లు ఎపోక్ (జనవరి 1, 1970) కంటే ముందటి తేదీలను సూచిస్తాయి. ఉదాహరణకు, −86400 అనేది డిసెంబర్ 31, 1969కి అనుగుణంగా ఉంటుంది.
  • ✓ మిల్లీసెకన్ల టైమ్‌స్టాంప్‌లను నమోదు చేయడానికి ముందు 1,000 తో భాగించాలి; కన్వర్టర్ సెకన్లను ఇన్‌పుట్‌గా అంగీకరిస్తుంది మరియు ఫలితాల్లో మిల్లీసెకన్ల సమానత్వాన్ని ప్రదర్శిస్తుంది.
గమనికలు
  • JavaScript యొక్క Date.now() మరియు Java యొక్క System.currentTimeMillis() మిల్లీసెకన్లను అందిస్తాయి, సెకన్లను కాదు — ఇక్కడ విలువను నమోదు చేసే ముందు 1,000తో భాగించండి లేదా పోలిక కోసం మిల్లీసెకన్ల అవుట్‌పుట్‌ను ఉపయోగించండి.
  • 2038 సంవత్సరం సమస్య 32-బిట్ సైన్డ్-ఇంటిజర్ టైమ్‌స్టాంప్‌లను ప్రభావితం చేస్తుంది, ఇవి జనవరి 19, 2038 03:14:07 UTCన ఓవర్‌ఫ్లో అవుతాయి. చాలా ఆధునిక సిస్టమ్‌లు 64-బిట్ టైమ్‌స్టాంప్‌లకు మారాయి.
  • API ప్రతిస్పందనలు లేదా లాగ్ ఫైల్‌లను డీబగ్ చేసేటప్పుడు, సరిగ్గా 3,600 లేదా 7,200 సెకన్ల తేడాతో ఉన్న టైమ్‌స్టాంప్‌లను గమనించండి — ఇది సాధారణంగా పైప్‌లైన్‌లో ఎక్కడో టైమ్-జోన్ ఆఫ్‌సెట్ వర్తింపజేయబడిందని (లేదా వదిలివేయబడిందని) సూచిస్తుంది.
  • ఎపోక్ టైమ్ ఎల్లప్పుడూ క్రమంగా పెరుగుతూ ఉంటుంది (లీప్-సెకండ్ సర్దుబాట్లను మినహాయించి), ఇది ఈవెంట్‌లను క్రమబద్ధీకరించడానికి, వ్యవధిని లెక్కించడానికి మరియు ప్రత్యేకమైన సమయ-ఆధారిత ఐడెంటిఫైయర్‌లను రూపొందించడానికి అనువైనదిగా చేస్తుంది.
మూలాలు
  1. The Open Group Base Specifications — ఎపోక్ నుండి సెకన్లు — POSIX టైమ్ మోడల్
  2. RFC 3339 — ఇంటర్నెట్‌లో తేదీ మరియు సమయం: టైమ్‌స్టాంప్‌లు — ఇంటర్నెట్ టైమ్‌స్టాంప్ ఫార్మాట్

Unix టైమ్‌స్టాంప్‌లు అంటే ఏమిటి?

Unix టైమ్‌స్టాంప్ అనేది జనవరి 1, 1970 అర్ధరాత్రి UTC (Unix epoch) నుండి గడిచిన సెకన్ల సంఖ్య. డేటాబేస్‌లు, APIలు, లాగ్ ఫైల్‌లు మరియు చాలా ప్రోగ్రామింగ్ భాషలలో సమయాన్ని సూచించడానికి ఈ పూర్ణాంకం ప్రామాణికమైనది. ఇది టైమ్-జోన్‌తో సంబంధం లేకుండా నిరంతరం పెరుగుతూ ఉంటుంది కాబట్టి, సార్టింగ్, వ్యవధి గణనలు మరియు సమయ ఆధారిత పోలికలను సులభతరం చేస్తుంది. JavaScript యొక్క Date.now() మరియు అనేక APIలు మిల్లీసెకన్లను (1,000 × సెకన్లు) అందిస్తాయి, కాబట్టి ఇక్కడ మిల్లీసెకన్ల విలువను నమోదు చేసే ముందు 1,000తో భాగించండి. ప్రతికూల (Negative) టైమ్‌స్టాంప్‌లు 1970కి ముందు తేదీలను సూచిస్తాయి; ఉదాహరణకు, −86400 అనేది epochకి సరిగ్గా ఒక రోజు ముందు సమయం.

epoch సమయం కోసం డెవలపర్ వినియోగ సందర్భాలు

డెవలపర్లు డేటాబేస్‌లలో ఈవెంట్ సమయాలను నిల్వ చేసేటప్పుడు, JSON APIలలో తేదీలను సీరియలైజ్ చేసేటప్పుడు, సమయ ఆధారిత కాష్ కీలను రూపొందించేటప్పుడు మరియు లాగ్ ఎంట్రీలను డీబగ్ చేసేటప్పుడు Unix టైమ్‌స్టాంప్‌లను ఉపయోగిస్తారు. సమర్థవంతమైన ఇండెక్సింగ్ మరియు రేంజ్ క్వెరీల కోసం డేటాబేస్ కాలమ్‌లు తరచుగా టైమ్‌స్టాంప్‌లను పూర్ణాంకాలుగా నిల్వ చేస్తాయి. టైమ్-జోన్ గందరగోళాన్ని నివారించడానికి API ప్రతిస్పందనలు తరచుగా epoch సెకన్లు లేదా మిల్లీసెకన్లను అందిస్తాయి. డీబగ్గింగ్ చేసేటప్పుడు, లాగ్ లేదా JWT క్లెయిమ్ నుండి రా టైమ్‌స్టాంప్‌ను మనిషి చదవగలిగే తేదీగా మార్చడం ద్వారా ఆ విలువ సరైనదా లేదా టైమ్-జోన్ కారకం వల్ల మారిందా అనేది త్వరగా తెలుస్తుంది. Epoch సమయం కూడా రేట్ లిమిటింగ్, సెషన్ గడువు ముగియడం మరియు డిస్ట్రిబ్యూటెడ్ సిస్టమ్స్‌లో సార్ట్ చేయగల ప్రత్యేక ఐడెంటిఫైయర్‌లను రూపొందించడానికి ఉపయోగించబడుతుంది.

ఎపోక్ టైమ్ కన్వర్టర్ FAQs

Unix ఎపోక్ అంటే ఏమిటి?

Unix ఎపోక్ అనేది Unix సమయాన్ని కొలిచే ప్రారంభ స్థానం: జనవరి 1, 1970 అర్ధరాత్రి UTC (1970-01-01T00:00:00Z). 0 టైమ్‌స్టాంప్ సరిగ్గా ఆ క్షణానికి అనుగుణంగా ఉంటుంది.

నా JavaScript టైమ్‌స్టాంప్‌లో ఎక్కువ అంకెలు ఎందుకు ఉన్నాయి?

JavaScript యొక్క Date.now() ఎపోక్ (epoch) నుండి మిల్లీసెకన్లను అందిస్తుంది, సెకన్లను కాదు. ఈ టూల్ ఉపయోగించే సెకన్ల ఆధారిత ఫార్మాట్‌లోకి మార్చడానికి 1,000తో భాగించండి లేదా నేరుగా మిల్లీసెకన్ల అవుట్‌పుట్‌తో పోల్చండి.

నేను నెగటివ్ టైమ్‌స్టాంప్‌ను నమోదు చేయవచ్చా?

అవును. నెగటివ్ విలువలు ఎపోక్ కంటే ముందు తేదీలను సూచిస్తాయి. ఉదాహరణకు, −86400 అనేది 1969-12-31T00:00:00Z కి సమానం, ఇది ఎపోక్ కంటే సరిగ్గా ఒక రోజు ముందు.

ఇది లీపు సెకన్లను (leap seconds) హ్యాండిల్ చేస్తుందా?

లేదు, మరియు ఇది POSIX ప్రమాణానికి అనుగుణంగా ఉంటుంది. POSIX సమయం ప్రతి రోజు సరిగ్గా 86,400 సెకన్లు అని భావిస్తుంది. 1972 నుండి చేర్చబడిన 27 లీపు సెకన్లు విడిగా సూచించబడవు, అంటే లీపు సెకన్ల సరిహద్దుల వద్ద UTC మరియు Unix సమయం ఒక సెకను వరకు తేడా ఉండవచ్చు.

2038 సంవత్సరం సమస్య ఏమిటి?

Unix సమయాన్ని 32-bit సైన్డ్ ఇంటిజర్‌గా నిల్వ చేసే సిస్టమ్‌లు జనవరి 19, 2038న 03:14:07 UTC వద్ద ఓవర్‌ఫ్లో అవుతాయి, ఇది పెద్ద నెగటివ్ నంబర్‌గా మారి 1901లోని తేదీలను చూపుతుంది. చాలా ఆధునిక ప్లాట్‌ఫారమ్‌లు ఇప్పుడు 64-bit టైమ్‌స్టాంప్‌లను ఉపయోగిస్తున్నాయి, ఇవి 290 బిలియన్ సంవత్సరాల వరకు ఓవర్‌ఫ్లో కావు.

రాసిన వారు జాన్ క్రెనెక్ వ్యవస్థాపకుడు మరియు ప్రధాన డెవలపర్
సమీక్షించిన వారు DigitSum పద్ధతుల సమీక్ష ఫార్ములా ధృవీకరణ మరియు QA
చివరిగా నవీకరించబడింది 10, మార్చి 2026

దీనిని అంచనాగా మాత్రమే ఉపయోగించండి మరియు ముఖ్యమైన నిర్ణయాలను అర్హత కలిగిన నిపుణుడితో ధృవీకరించుకోండి.

భవిష్యత్తులో ఏదైనా ఫీచర్ ప్రత్యేకంగా చెబితే తప్ప, ఇన్‌పుట్‌లు బ్రౌజర్‌లోనే ఉంటాయి.