Unix ടൈംസ്റ്റാമ്പ് പരിവർത്തകത്തിനുള്ള ഡവലപ്പർ ഗൈഡ്
Unix ടൈംസ്റ്റാമ്പ് മാറ്റുന്ന ഉപകരണം mastered ചെയ്യുക. എപ്പോക് സമയം മനുഷ്യന് വായിക്കാവുന്ന തീയതികളിലേക്ക് മാറ്റാൻ, വ്യത്യസ്ത ഭാഷകൾ കൈകാര്യം ചെയ്യാൻ, സാധാരണ ഡെവലപ്പർ പിഴവുകൾ ഒഴിവാക്കാൻ പഠിക്കുക.
ശുപാർശ ചെയ്ത വിപുലീകരണങ്ങൾ
ഒരു യൂണിക്സ് ടൈംസ്റ്റാംപ് കൺവെർട്ടർ ഒരു ഡവലപ്പറോ ഡേറ്റ അനലിസ്റ്റോ എന്ന നിലയിൽ നിങ്ങൾ നിരന്തരം ഉപയോഗിക്കേണ്ടിവരുന്ന ലളിതമായ പക്ഷേ അനിവാര്യമായ ഉപകരണങ്ങളിലൊന്നാണ്. ഇത് ഒരു ദൈർഘ്യമുള്ള, കാഴ്ചയിൽ യാദൃശ്ചികമായ സംഖ്യയെ നമുക്ക് യഥാർത്ഥത്തിൽ മനസ്സിലാക്കാൻ കഴിയുന്ന ഒരു തീയതിയും സമയവുമായി വിവർത്തനം ചെയ്യുന്ന ഒരു ഉപയോഗപ്രദമായ യൂട്ടിലിറ്റിയാണ്. സിസ്റ്റം ലോഗുകൾ പരിശോധിക്കുമ്പോഴും, API-കളുമായി പ്രവർത്തിക്കുമ്പോഴും, അല്ലെങ്കിൽ ഈ അതികാര്യക്ഷമമായ ഫോർമാറ്റിൽ സമയം സൂക്ഷിച്ചിരിക്കുന്ന ഡേറ്റാബേസുകൾ ചോദ്യം ചെയ്യുമ്പോഴും ഈ വിവർത്തനം നിർണായകമാണ്.
യൂണിക്സ് ടൈംസ്റ്റാംപ് എന്നാൽ എന്താണ്, എന്തുകൊണ്ടാണ് ഇത് പ്രധാനമായിരിക്കുന്നത്
നല്ല ഒരു കൺവെർട്ടറിനെ ശരിയായി വിലമതിക്കാൻ മുമ്പ്, ആ നമ്പർ യഥാർത്ഥത്തിൽ എന്താണ് എന്ന് നിങ്ങൾ മനസ്സിലാക്കണം. അടിസ്ഥാനപരമായി, ഒരു യൂണിക്സ് ടൈംസ്റ്റാമ്പ് സെക്കൻഡുകളുടെ ഒരു നടപ്പായ എണ്ണം മാത്രമാണ്. 1970 ജനുവരി 1-ന് 00:00:00 UTC മുതൽ കടന്നുപോയ ആകെ സെക്കൻഡുകളുടെ എണ്ണം ഇത് ട്രാക്ക് ചെയ്യുന്നു. ആ പ്രത്യേക സമയം "യൂണിക്സ് എപോക്ക്" എന്ന് പ്രശസ്തമായി അറിയപ്പെടുന്നു.
എന്തുകൊണ്ട് ഈ രീതി? ലളിതത്വവും കാര്യക്ഷമതയും. സമയത്തെ ഒരൊറ്റ പൂർണ്ണസംഖ്യയായി സംഭരിക്കുന്നത് "Friday, January 1, 2021 12:00:00 AM GMT" പോലുള്ള വിശദമായ ഒരു സ്ട്രിംഗിനേക്കാൾ വളരെ ചെറുതും കാര്യക്ഷമവുമാണ്. ഇത് ചില പ്രധാന മേഖലകൾക്ക് മികച്ചതാക്കുന്നു:
- ഡാറ്റാബേസ് സ്റ്റോറേജ്: ടൈംസ്റ്റാമ്പുകൾ ചെറുതാണ്, അതിനാൽ അവ ഇൻഡെക്സ് ചെയ്യാനും ചോദ്യം ചെയ്യാനും വേഗത്തിലാണ്. പ്രകടനത്തിന് ഇത് വലിയ നേട്ടമാണ്.
- API പേലോഡുകൾ: ഒരൊറ്റ നമ്പർ പുറകോട്ടും മുൻപോട്ടും അയക്കുന്നത് മുഴുവൻ ഡേറ്റാ സ്ട്രിംഗ് അയക്കുന്നതിനേക്കാൾ ബാൻഡ്വിഡ്ത്തിൽ ഭാരം കുറഞ്ഞതാണ്, ഇത് വേഗത്തിലുള്ള പ്രതികരണ സമയങ്ങളിലേക്ക് നയിക്കുന്നു.
- ലോഗ് ഫയലുകൾ: പതിനെണ്ണം വ്യത്യസ്ത സിസ്റ്റങ്ങളിൽ നിന്നുള്ള ലോഗുകൾ പാഴ്സ് ചെയ്യുമ്പോൾ, ഒരു ഏകീകൃത, ഭാഷാനിഷ്പക്ഷമായ ടൈംസ്റ്റാമ്പ് ഉണ്ടായിരിക്കുന്നത് ഒരു രക്ഷാദാരമാണ്.
- കണക്കുകൂട്ടലുകൾ: ഒരു പ്രക്രിയ എത്ര നേരം എടുത്തു എന്ന് അറിയേണ്ടതുണ്ടോ? ആരംഭ ടൈംസ്റ്റാമ്പിൽ നിന്ന് അവസാന ടൈംസ്റ്റാമ്പ് കുറയ്ക്കുക മാത്രം ചെയ്താൽ മതി. ഇത് ലളിതമായ ഇന്റീജർ ഗണിതമാണ്.
സെക്കൻഡുകൾ, മില്ലിസെക്കൻഡുകൾ തുടങ്ങിയവ
ക്ലാസിക് യൂണിക്സ് ടൈംസ്റ്റാമ്പ് എന്നത് സെക്കൻഡുകളെ സൂചിപ്പിക്കുന്ന 10-അക്ഷര നമ്പറാണ്. പക്ഷേ, സാങ്കേതികവിദ്യ പുരോഗമിക്കുന്നതിനനുസരിച്ച്, കൂടുതൽ സൂക്ഷ്മമായ സമയ രേഖപ്പെടുത്തലിനുള്ള ആവശ്യകത വർദ്ധിച്ചു. തന്ത്രപരമായി തന്നെ, നിങ്ങൾ വ്യത്യസ്ത നീളത്തിലുള്ള ടൈംസ്റ്റാമ്പുകൾ കാണാൻ തുടങ്ങുന്നത് ഇവിടെയാണ്, അത് ഒരു സാധാരണ തടസ്സപ്പെടുത്തലാണ്.
പ്രകൃതിയിൽ നിങ്ങൾക്ക് സാധാരണയായി നേരിടാൻ കഴിയുന്നവയുടെ ഒരു ദ്രുത വിശകലനം ഇതാണ്. ഒന്നിനെ മറ്റൊന്നുമായി തെറ്റിദ്ധരിക്കുന്നത് ഒരു ക്ലാസിക് "ആയിരം തെറ്റ്" പിശകാണ്, ഇത് ചില വളരെ ആശയക്കുഴപ്പമുണ്ടാക്കുന്ന ബഗ്ഗുകളിലേക്ക് നയിക്കാം.
സാധാരണ യൂണിക്സ് ടൈംസ്റ്റാമ്പ് ഫോർമാറ്റുകൾ ഒരു നോട്ടത്തിൽ
| യൂണിറ്റ് | അക്ഷരങ്ങൾ | സാധാരണ ഉപയോഗ കേസ് | ഉദാഹരണ വില (ഒരേ നിമിഷത്തിന്) |
|---|---|---|---|
| സെക്കൻഡുകൾ | 10 | മിക്ക ബാക്കെൻഡ് സിസ്റ്റങ്ങൾ, ഡാറ്റാബേസുകൾ, API-കൾ എന്നിവയുടെ സ്റ്റാൻഡേർഡ്. | 1609459200 |
| മൈലിസെക്കൻഡുകൾ | 13 | വെബ് ടെക്നോളജിയിൽ വളരെ സാധാരണമാണ്, പ്രത്യേകിച്ചും JavaScript. | 1609459200000 |
| മൈക്രോസെക്കൻഡുകൾ | 16 | ഹൈ-ഫ്രീക്വൻസി ട്രേഡിംഗിലോ ശാസ്ത്രീയ കണക്കുകൂട്ടലുകളിലോ ഉപയോഗിക്കുന്നു. | 1609459200000000 |
ഈ ഫോർമാറ്റുകൾ വ്യക്തമായി മനസ്സിലാക്കുക എന്നത് നിർണായകമാണ്. ഒരു ഉപകരണം സെക്കൻഡുകൾ പ്രതീക്ഷിക്കുകയും നിങ്ങൾ അതിന് മൈലിസെക്കൻഡുകൾ നൽകുകയും ചെയ്താൽ, നിങ്ങൾക്ക് ലഭിക്കുന്നത് ആയിരക്കണക്കിന് വർഷം ഭാവിയിലുള്ള ഒരു തീയതിയായിരിക്കും. ഏതോ ഒരു ഘട്ടത്തിൽ നമ്മളെല്ലാവരും ചെയ്തിട്ടുള്ള ഒരു തെറ്റാണ് ഇത്!
പ്രസിദ്ധമായ 2038 പ്രശ്നം
യൂണിക്സ് സമയമുദ്രയുടെ മനോഹരമായ ലാളിത്യം ഒരു ടിക്കിങ് ടൈം ബോംബും സൃഷ്ടിച്ചു: "വർഷം 2038 പ്രശ്നം." പഴയ 32-ബിറ്റ് സിസ്റ്റങ്ങളിൽ, സമയമുദ്രകൾ ഒരു സൈൻ ചെയ്ത 32-ബിറ്റ് ഇന്റജർ ആയി സൂക്ഷിക്കപ്പെട്ടിരുന്നു. പ്രശ്നം എന്നത് ഈ തരം ഇന്റജറിന് ഒരു പരിധി ഉണ്ട് എന്നതാണ്—ഇതിന് 2,147,483,647.
വലിയ ഒരു സംഖ്യ ഉൾക്കൊള്ളാൻ കഴിയില്ല. 2038 ജനുവരി 19-ന്, UTC 03:14:07 മുതൽ, എപ്പോക്കിൽ നിന്നുള്ള സെക്കൻഡുകളുടെ എണ്ണം ആ പരിധി കവിയും. അത് സംഭവിക്കുമ്പോൾ, ഇന്റജർ "വ്രാപ്പ് അറൗണ്ട്" ചെയ്യുകയും നെഗറ്റീവ് നമ്പറായി മാറുകയും ചെയ്യും. ഇത് ദുർബലമായ സിസ്റ്റങ്ങളെ 1901 എന്ന തീയതിയായി വ്യാഖ്യാനിക്കാൻ ഇടയാക്കും, അത് ഇപ്പോഴും പുറത്തുള്ള ബില്യൺ കണക്കിന് ലെഗസി ഉപകരണങ്ങളെ തകർക്കാം. യൂണിക്സ് എപ്പോച്ചും അതിന്റെ സ്വാധീനവും കുറിച്ച് StrongDM-ലെ വിദഗ്ധരിൽ നിന്ന് കൂടുതൽ വീക്ഷണങ്ങൾ നിങ്ങൾക്ക് ലഭിക്കും.
ഭാഗ്യവശാൽ, ഇത് നമ്മളിൽ ഭൂരിഭാഗവും ദിവസവും ആശങ്കപ്പെടേണ്ട കാര്യമല്ല. ആധുനിക സിസ്റ്റങ്ങളിൽ വലിയ ഭൂരിഭാഗവും സമയം കൈകാര്യം ചെയ്യാൻ 64-ബിറ്റ് ഇന്റജറുകളിലേക്ക് മാറിയിട്ടുണ്ട്. ഒരു 64-ബിറ്റ് ഇന്റജർ അത്ര വലുതാണ്, ഇനി 292 ബില്യൺ വർഷങ്ങൾക്ക് ശേഷവും അത് ഓവർഫ്ലോ ചെയ്യില്ല, പ്രശ്നം എന്നേക്കും പരിഹരിക്കുന്നു.
എന്നിരുന്നാലും, പഴയ എംബെഡഡ് സിസ്റ്റങ്ങളിലോ ലെഗസി കോഡ്ബേസുകളിലോ പ്രവർത്തിക്കേണ്ടിവരുമ്പോൾ, ഇത് കണ്ടെത്താൻ കഴിയുന്ന കമ്പ്യൂട്ടിംഗ് ചരിത്രത്തിലെ അടിപൊളിയായ ഒരു അംശവും നിർണായകമായ അറിവും തന്നെയാണ്. ഈ അടിസ്ഥാന ആശയങ്ങൾ മനസ്സിലാക്കുന്നത് നിങ്ങളുടെ കൈയിലുള്ള ഏതൊരു യൂണിക്സ് ടൈംസ്റ്റാംപ് കൺവെർട്ടറിനെയും വളരെ ശക്തമായ ഒരു ഉപകരണമാക്കി മാറ്റുന്നു.
ബ്രൗസറിൽ വിളികൾ എളുപ്പമാക്കുന്നു
ടെർമിനൽ കമാൻഡോ കോഡ് സ്നിപ്പറ്റോ ഉപയോഗിക്കുന്നത് പ്രവർത്തികൾ ചെയ്തുതീർക്കാൻ എപ്പോഴും ഏറ്റവും വേഗത്തിലുള്ള മാർഗം അല്ല. ചിലപ്പോൾ, നിങ്ങൾക്ക് ആവശ്യം ഉടൻ തന്നെ ഒരു ഉത്തരം വേണം, നിങ്ങളുടെ ശ്രദ്ധ തെറ്റിക്കാതെയോ വിൻഡോകൾ മാറ്റാതെയോ. നല്ലൊരു ബ്രൗസർ അടിസ്ഥാനമാക്കിയുള്ള ഉപകരണം, പ്രത്യേകിച്ച് നിങ്ങളുടെ ബ്രൗസറിനുള്ളിൽ തന്നെ സ്ഥിതിചെയ്യുന്ന ഒരു പ്രത്യേക യൂണിക്സ് ടൈംസ്റ്റാംപ് കൺവെർട്ടർ, ഇവിടെ യഥാർത്ഥമായും അതിന്റെ വില തെളിയിക്കുന്നു.
ഇവിടെയുള്ള യഥാർത്ഥ മാന്ത്രികത, ഫ്ലോയിൽ നിലനിൽക്കുക എന്നതാണ്. ഇത് ചിത്രീകരിക്കുക: നിങ്ങൾ നിങ്ങളുടെ ബ്രൗസറിലെ ഡവലപ്പർ ടൂളുകളിൽ ഒരു API റെസ്പോൺസ് ഖനനം ചെയ്യുകയും ഒരു ടൈംസ്റ്റാംപ് കാണുകയും ചെയ്യുന്നു. മറ്റൊരു ടാബ് തുറക്കുകയോ ടെർമിനൽ ആരംഭിക്കുകയോ ചെയ്യുന്നതിന് പകരം, നിങ്ങൾ ഒരു ദ്രുത കീബോർഡ് ഷോർട്ട്കട്ട് അമർത്തി, നമ്പർ പേസ്റ്റ് ചെയ്യുകയും ഉടൻ തന്നെ ഉത്തരം നേടുകയും ചെയ്യുന്നു. ShiftShift Extensions പോലുള്ള ഉപകരണങ്ങളുമായി നിങ്ങൾക്ക് ലഭിക്കുന്നത് തന്നെയാണ് ഇത്തരം സീരിയസ് ഫ്ലോ, അവ ഒരു കമാൻഡ് പാലറ്റിലേക്ക് ധാരാളം ഉപകാരപ്രദമായ യൂട്ടിലിറ്റികൾ പായ്ക്ക് ചെയ്യുന്നു.
കീബോർഡ് ഷോർട്ട്കട്ട് ഉപയോഗിച്ച് ഇൻസ്റ്റന്റ് ഉത്തരങ്ങൾ നേടുക
ഇത് എല്ലാം വേഗത്തെ ആശ്രയിച്ചിരിക്കുന്നു. ShiftShift പോലൊരു ഉപകരണം ഉപയോഗിച്ചാൽ, Shift കീയിൽ (അല്ലെങ്കിൽ Mac-ൽ Cmd+Shift+P) ഒരു പെട്ടെന്നുള്ള ഡബിൾ ടാപ്പ് ചെയ്താൽ കമാൻഡ് ബാർ തുറക്കും. "ടൈംസ്റ്റാമ്പ്" എന്ന് ടൈപ്പ് ചെയ്യാൻ തുടങ്ങൂ, കൺവെർട്ടർ പ്രത്യക്ഷപ്പെടും. നിങ്ങളുടെ മൂല്യം പേസ്റ്റ് ചെയ്യൂ, മനുഷ്യർക്ക് വായിക്കാവുന്ന ഒരു തീയതി നിമിഷത്തിനുള്ളിൽ ലഭിക്കും.
ഇത് എങ്ങനെയാണെന്ന് നോക്കൂ—ഈ കമാൻഡ് പാലറ്റ് നിങ്ങളുടെ നിലവിലെ പേജിനു മുകളിൽ ഒരു ടൈംസ്റ്റാമ്പ് പരിവർത്തനം ചെയ്യാൻ തയ്യാറായി കാത്തിരിക്കുകയാണ്.
ഏറ്റവും നല്ല കാര്യം, അത് നിങ്ങളെ അലോസരപ്പെടുത്താതെ എങ്ങനെ സംയോജിപ്പിക്കുന്നു എന്നതാണ്. കൺവെർട്ടർ ഒരേ ഓവർലേയിൽ ലഭ്യമായ നിരവധി ഉപകരണങ്ങളിൽ ഒന്ന് മാത്രമാണ്, അതിനാൽ നിങ്ങൾ ചെയ്യുന്നത് വിട്ടുപോകേണ്ടി വരില്ല.
ഈ സമീപനം ഡവലപ്പർമാർക്കും ടെസ്റ്റർമാർക്കും ബ്രൗസറിൽ താമസിക്കുന്ന മറ്റെല്ലാവർക്കും രക്ഷാമാർഗമാണ്. കൂടാതെ, പരിവർത്തനം പൂർണ്ണമായും നിങ്ങളുടെ മെഷീനിൽ നടക്കുന്നു. ലോഗുകളിൽ നിന്നോ API മറുപടികളിൽ നിന്നോ ഉള്ള സെൻസിറ്റീവ് ഡാറ്റ ഒരിക്കലും നിങ്ങളുടെ കമ്പ്യൂട്ടർ വിട്ടുപോകുന്നില്ല, ഇത് സ്വകാര്യതയ്ക്ക് ഒരു വലിയ നേട്ടമാണ്.
ഒരു ടൈംസ്റ്റാമ്പ് പരിവർത്തനം ചെയ്യാനും, ഒരു അവ്യക്തമായ JSON ബ്ലോബ് റീഫോർമാറ്റ് ചെയ്യാനും, തുടർന്ന് ഒരു സമയ വ്യത്യാസം കണക്കാക്കാനും കഴിയുന്നത്—അതെല്ലാം ഒരേ ഇന്റർഫേസിൽ നിന്നുകൊണ്ട്—ഒരു വലിയ സമയ ലാഭമാണ്. ഇത് ഒരു അസ്വസ്ഥജനകമായ, ബഹു-ഉപകരണ പ്രക്രിയയെ ഒരൊറ്റ, മിനുസമുള്ള പ്രവർത്തനമാക്കി മാറ്റുന്നു.
ഒരു ഏക തന്ത്ര പോണിയല്ലാത്ത കൂടുതൽ
ബ്രൗസറിലെ ഒരു മികച്ച യുട്ടിൽ വളരെ അപൂർവ്വമായി മാത്രം ഒരൊറ്റ ഉപകരണമായിരിക്കില്ല; അത് ഒരു മുഴുവൻ ടൂൾക്കിറ്റിന്റെ ഭാഗമാണ്. ടൈംസ്റ്റാമ്പ് കൺവർട്ടറും മറ്റ് ഫംഗ്ഷനുകളും ഒരുമിച്ച് ഉപയോഗിക്കുന്നത് നിങ്ങൾക്ക് പതിവായി കാണാൻ കഴിയും.
ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് അത് ഇവയുമായി ജോടിയാക്കാം:
- ടൈംസ്റ്റാമ്പ് എടുക്കുന്നതിന് മുമ്പ് ചില കോഡ് വൃത്തിയാക്കാൻ ഒരു JSON അല്ലെങ്കിൽ SQL ഫോർമാറ്റർ .
- ആകെ മൂല്യങ്ങളിൽ വേഗത്തിലുള്ള ഗണിതശാസ്ത്രം ചെയ്യാൻ ഒരു ബിൽറ്റ്-ഇൻ കാൽക്കുലേറ്റർ . (നിങ്ങൾക്ക് ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് കാണാൻ ShiftShift കാൽക്കുലേറ്റർ പേജിൽ ഒരു സമാന ടൂളുമായി കളിക്കാം).
- രണ്ട് API പ്രതികരണങ്ങൾ, ടൈംസ്റ്റാമ്പുകൾ എന്നിവയ്ക്കിടയിൽ വ്യത്യാസങ്ങൾ കണ്ടെത്താൻ ഒരു ടെക്സ്റ്റ് താരതമ്യ ടൂൾ .
ഇത്തരം എല്ലാ അടിസ്ഥാന സൗകര്യങ്ങളും ഒരിടത്ത് ലഭ്യമാക്കുന്നത് ഒരു വേഗത്തിലുള്ളതും കൂടുതൽ ഏകീകൃതവുമായ വർക്ക്ഫ്ലോ സൃഷ്ടിക്കുന്നു. ഇത് സൗകര്യത്തെക്കുറിച്ച് മാത്രമല്ല—ഇത് ദിവസം മുഴുവൻ കൂട്ടിച്ചേർക്കുകയും നിങ്ങളുടെ ഉത്പാദനക്ഷമതയെ ഇല്ലാതാക്കുകയും ചെയ്യുന്ന എല്ലാ ചെറിയ, ആവർത്തിക്കുന്ന തടസ്സങ്ങളും ഇല്ലാതാക്കുന്നതിനെക്കുറിച്ചാണ്.
കോഡിൽ പ്രായോഗിക ടൈംസ്റ്റാമ്പ് പരിവർത്തനങ്ങൾ
നിങ്ങൾ ഒരു ഡവലപ്പർ ആണെങ്കിൽ, ടൈംസ്റ്റാമ്പുകൾ കൈകാര്യം ചെയ്യുന്നത് ജോലിയുടെ ഒരു ഭാഗം മാത്രമാണെന്ന് നിങ്ങൾക്കറിയാം. പക്ഷേ ആത്മാർത്ഥമായി പറഞ്ഞാൽ, ഒരു ഭാഷയിൽ നിന്ന് മറ്റൊന്നിലേക്കുള്ള സിന്റാക്സ് ഒരിക്കലും തികച്ചും ഒരുപോലെയായിരിക്കില്ല. ഈ വിഭാഗം നിങ്ങളുടെ പ്രധാന ചീറ്റ് ഷീറ്റ് ആണ്, നിങ്ങൾ യഥാർത്ഥത്തിൽ ജോലി ചെയ്യുന്ന പ്ലാറ്റ്ഫോമുകൾക്കായി ഉടൻ തന്നെ എടുത്തുപയോഗിക്കാവുന്ന കോഡ് സ്നിപ്പെറ്റുകളാൽ നിറഞ്ഞിരിക്കുന്നു. പഴയ സ്റ്റാക്ക് ഓവർഫ്ലോ ത്രെഡുകളിൽ തെരയുന്നത് ഇനി ആവശ്യമില്ല— നിങ്ങളെ മുന്നോട്ട് നയിക്കാൻ പ്രായോഗിക ഉദാഹരണങ്ങൾ മാത്രം.
വെബ് ഫ്രണ്ട്-എൻഡിൽ ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതോ, ഒരു പൈതൺ സ്ക്രിപ്റ്റ് എഴുതുന്നതോ, അല്ലെങ്കിൽ ഒരു ഡാറ്റാബേസ് ചോദ്യം ചെയ്യുന്നതോ ആയാലും, ഇപോക്ക് സമയം പരിവർത്തനം ചെയ്യുന്നത് ഒരു അടിസ്ഥാന നൈപുണ്യമാണ്. ഒരു ഇപോക്ക് ഇന്റജർ വായനാശൂന്യമായ ഒരു സ്ട്രിങ്ങാക്കി മാറ്റുന്നത് മുതൽ അത് തിരിച്ചും ചെയ്യുന്നത് വരെ, ഏറ്റവും സാധാരണമായ സാഹചര്യങ്ങളിലൂടെ നമ്മൾ കടന്നുപോകും.
ജാവസ്ക്രിപ്റ്റിൽ ടൈംസ്റ്റാമ്പുകൾ പരിവർത്തനം ചെയ്യുന്നത്
JavaScript's Date ഒബ്ജക്റ്റ് ഇവിടെ നിങ്ങളുടെ പ്രധാന ഉപകരണമാണ്, പക്ഷേ ഇതിന് ഡവലപ്പർമാരെ എപ്പോഴും കുഴപ്പത്തിലാക്കുന്ന ഒരു പ്രധാന പ്രത്യേകതയുണ്ട്: ഇത് മില്ലിസെക്കൻഡ്കളിലാണ് പ്രവർത്തിക്കുന്നത്, സെക്കൻഡുകളിലല്ല. നിങ്ങളുടെ മുൻഭാഗം സ്റ്റാൻഡേർഡ് 10-അക്കം, സെക്കൻഡ് അടിസ്ഥാനമാക്കിയുള്ള ടൈംസ്റ്റാമ്പുകൾ ഉപയോഗിക്കുന്ന ഒരു ബാക്കെൻഡുമായി സംസാരിക്കുമ്പോൾ ഇത് ക്ലാസിക് ബഗുകളുടെ ഉറവിടമാണ്.
ഒരു സ്റ്റാൻഡേർഡ് യൂണിക്സ് ടൈംസ്റ്റാമ്പിനെ (സെക്കൻഡുകളിൽ) Date ഒബ്ജക്റ്റിലേക്ക് ശരിയായി പരിവർത്തനം ചെയ്യാൻ, അത് 1000.
// A standard 10-digit Unix timestamp (in seconds)
const unixTimestamp = 1672531200;
// Convert to milliseconds, then create a Date object
const dateObject = new Date(unixTimestamp * 1000);
// Format into a readable UTC string
// Output: Sun, 01 Jan 2023 00:00:00 GMT
console.log(dateObject.toUTCString());
ഇപ്പോഴത്തെ ടൈംസ്റ്റാമ്പ് വേണോ? Date.now() അത് നിങ്ങൾക്ക് മില്ലിസെക്കൻഡുകളിൽ നൽകുന്നു. ഒരു API-യിലേക്ക് മാനദണ്ഡമായ 10-അക്ക ടൈംസ്റ്റാമ്പ് തിരികെ അയയ്ക്കുന്നതിന് മുമ്പ് 1000 കൊണ്ട് ഹരിക്കുകയും റൗണ്ട് ഡൗൺ ചെയ്യുകയും ചെയ്യുക എന്നത് ഓർക്കുക.
Python ഉപയോഗിച്ചുള്ള പരിവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യൽ
ബാക്കെൻഡിൽ, പൈത്തണ്ണിന്റെ datetime മൊഡ്യൂൾ ഒരു ശക്തികേന്ദ്രമാണ്. ഇത് അതിശയകരമായ വഴക്കമുള്ളതും സമയമേഖല അറിയുന്ന രൂപാന്തരപ്പെടുത്തലുകൾക്ക് മികച്ച പിന്തുണയും നൽകുന്നു, വ്യത്യസ്ത പ്രദേശങ്ങളിൽ കൃത്യമായി സമയം കൈകാര്യം ചെയ്യേണ്ട സേവനങ്ങൾക്ക് ഇത് ഒരു വിശ്വസനീയമായ ഓപ്ഷൻ ആക്കുന്നു.
datetime ലൈബ്രറി ഉപയോഗിച്ച് ഒരു ടൈംസ്റ്റാമ്പ് രൂപാന്തരപ്പെടുത്തുന്നതിനുള്ള ലളിതമായ മാർഗം ഇതാ:
import datetime
ഒരു സാധാരണ 10-അക്ഷര യൂണിക്സ് ടൈംസ്റ്റാമ്പ്
unix_timestamp = 1672531200
ടൈംസ്റ്റാമ്പിനെ ഒരു ഡേറ്റിം ഒബ്ജക്റ്റായി മാറ്റുക
datetime_obj = datetime.datetime.fromtimestamp(unix_timestamp)
അതിനെ വൃത്തിയുള്ള, മനുഷ്യർക്ക് വായിക്കാവുന്ന സ്ട്രിംഗായി ഫോർമാറ്റ് ചെയ്യുക
ഔട്ട്പുട്ട്: 2023-01-01 00:00:00
print(datetime_obj.strftime('%Y-%m-%d %H:%M:%S'))
ഈ ലളിതമായ സമീപനം നിങ്ങളുടെ പൈത്തൺ ആപ്പുകളിൽ എപ്പോക്ക് സമയം കൈകാര്യം ചെയ്യുന്നതിന് ഒരു വൃത്തിയുള്ളതും ആശ്രയിക്കാവുന്നതുമായ മാർഗം നൽകുന്നു. ടൈംസ്റ്റാമ്പുകൾ ഉൾക്കൊള്ളുന്ന JSON പോലുള്ള സങ്കീർണ്ണമായ ഡാറ്റാ സ്ട്രക്ചറുകളുമായി നിങ്ങൾ പ്രവർത്തിക്കുകയാണെങ്കിൽ, ഡീബഗ്ഗിംഗിനായി ഞങ്ങളുടെ JSON ഫോർമാറ്റർ ഉപയോഗിക്കുന്നതിനുള്ള ഞങ്ങളുടെ ഗൈഡ് നിങ്ങൾക്ക് ഉപകാരപ്പെട്ടേക്കാം.
SQL ഉപയോഗിച്ച് ഡേറ്റാബേസ് രൂപാന്തരപ്പെടുത്തലുകൾ
ഡേറ്റാബേസുകൾ പ്രായത്തെ പലപ്പോഴും യൂണിക്സ് ടൈംസ്റ്റാമ്പുകളായി സൂക്ഷിക്കുന്നു, കാരണം അവ കാര്യക്ഷമമാണ്. നല്ല വാർത്ത എന്നത് മിക്ക എസ്ക്യുഎൽ ഡയലക്റ്റുകൾക്കും ഈ രൂപാന്തരപ്പെടുത്തലുകൾ നിങ്ങളുടെ ചോദ്യങ്ങൾക്കുള്ളിൽ തന്നെ കൈകാര്യം ചെയ്യാൻ ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനുകൾ ഉണ്ട് എന്നതാണ്. അസംസ്കൃത ഇന്റിജർ ടൈംസ്റ്റാമ്പുകൾ എടുത്ത് നിങ്ങളുടെ ആപ്ലിക്കേഷൻ കോഡിൽ രൂപാന്തരപ്പെടുത്തുന്നതിനേക്കാൾ ഇത് വളരെ കാര്യക്ഷമമാണ്.
യൂണിക്സ് ടൈംസ്റ്റാമ്പ് ഏറെക്കുറെ സാർവത്രികമാണ്, ഇത് 90% പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ—ജാവസ്ക്രിപ്റ്റിന്റെ Date.now() Python-ന്റെ time.time()— ദിവസവും ട്രില്യൺ കണക്കിന് ഓപ്പറേഷനുകൾ ശക്തിപ്പെടുത്തുന്നു. സമയമേഖലകൾ ശരിയായി കൈകാര്യം ചെയ്യേണ്ടത് നിർണായകമാണ്; ഒരു ഉറച്ച യൂണിക്സ് ടൈംസ്റ്റാമ്പ് കൺവെർട്ടർ ഇതിനേക്കാൾ കൂടുതൽ കൈകാര്യം ചെയ്യാൻ കഴിയും 400 IANA സോണുകൾ, ഒരു എസ്റ്റിമേറ്റഡ് പിശക് തടയാൻ സഹായിക്കുന്നു 62% ടൈംസോണുകൾ വ്യക്തമായി കൈകാര്യം ചെയ്യാത്ത ഗ്ലോബൽ അപ്ലിക്കേഷനുകളുടെ എണ്ണം. ഈ ഉപകരണങ്ങളുടെ ആഗോള ഉപയോഗത്തെക്കുറിച്ചുള്ള കൂടുതൽ വിശദാംശങ്ങൾ നിങ്ങൾക്ക് ഇവിടെ കാണാം Fossa.
ഡവലപ്പർമാർക്ക്, SQL ഫോർമാറ്റ് ചെയ്യാനും, ടൈംസ്റ്റാമ്പുകൾ പരിവർത്തനം ചെയ്യാനും, എപ്പോക്ക് വ്യത്യാസങ്ങൾ കണക്കാക്കാനും നിങ്ങളുടെ മഷീനിൽ നിന്ന് പുറത്തുപോകാതെ സാധിക്കുന്നത് ഒരു വലിയ ഉൽപാദനക്ഷമത നേട്ടമാണ്. ഈ ലോക്കൽ-ഫസ്റ്റ് സമീപനം GDPR, CCPA പോലുള്ള ആധുനിക ഡേറ്റ സ്വകാര്യത മാനദണ്ഡങ്ങളുമായി നിങ്ങളെ അനുയോജ്യമാക്കി നിലനിർത്തുന്നു.
MySQL ഉദാഹരണം
MySQL-ൽ, FROM_UNIXTIME() ഫംഗ്ഷൻ നിങ്ങൾ കൂടുതലായി ഉപയോഗിക്കുന്നതാണ്. ഇത് ഒരു എപ്പോച് ഇന്റജർ എടുത്ത് അതിനെ ഒരു സ്റ്റാൻഡേർഡ് DATETIME ഫോർമാറ്റിലേക്ക് മനോഹരമായി പരിവർത്തനം ചെയ്യുന്നു.
SELECT FROM_UNIXTIME(1672531200);
-- തിരികെ നൽകുന്നത്: '2023-01-01 00:00:00'
മറുവശത്തേക്ക്—ഒരു തീയതി സ്ട്രിംഗിൽ നിന്ന് തിരികെ ഒരു എപ്പോച് ടൈംസ്റ്റാമ്പിലേക്ക്— UNIX_TIMESTAMP().
SELECT UNIX_TIMESTAMP('2023-01-01 00:00:00');
-- തിരികെ നൽകുന്നത്: 1672531200
PostgreSQL ഉദാഹരണം
PostgreSQL ഒരു ചെറുതായി വ്യത്യസ്തമായ പക്ഷേ തുല്യശക്തമായ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു: to_timestamp(). ഈ ഫംഗ്ഷൻ നേരിട്ട് ഒരു യൂണിക്സ് ടൈംസ്റ്റാമ്പിനെ ഒരു TIMESTAMP WITH TIME ZONE മൂല്യമായി പരിവർത്തനം ചെയ്യുന്നു.
SELECT to_timestamp(1672531200);
-- തിരികെ നൽകുന്നത്: 2023-01-01 00:00:00+00
കാലമേഖലയെക്കുറിച്ച് അറിവുള്ളതായതുകൊണ്ട്, സമയ സൂക്ഷ്മത നിർബന്ധമായ ആഗോള പ്രേക്ഷകർക്കുവേണ്ടിയുള്ള ആപ്ലിക്കേഷനുകൾക്ക് ഇത് വളരെ ശക്തമായ ഒരു തിരഞ്ഞെടുപ്പാണ്.
ടെർമിനലിൽ ടൈംസ്റ്റാമ്പ് പരിവർത്തനങ്ങൾ മാസ്റ്റർ ചെയ്യുന്നത്
നിങ്ങൾ കമാൻഡ് ലൈനിൽ താമസിക്കുകയാണെങ്കിൽ, ഒരു ത്വരിത ടൈംസ്റ്റാമ്പ് പരിവർത്തനത്തിനായി ബ്രൗസറോ ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസോ ഉപയോഗിക്കുന്നത് യഥാർത്ഥത്തിൽ ഒരു വർക്ക്ഫ്ലോ കില്ലറാണ്. അത് നിങ്ങളുടെ ഏകാഗ്രത തകർക്കും. നല്ല വാർത്ത നിങ്ങൾക്ക് അങ്ങനെ ചെയ്യേണ്ടിവരില്ല എന്നതാണ്; ലിനക്സും macOS ഉം രണ്ടും ടെർമിനൽ വിട്ടുപോകാതെ തന്നെ ഈ പരിവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യാൻ ശക്തമായ, നേറ്റീവ് ഉപകരണങ്ങൾ നൽകുന്നു.
ഇതിനുവേണ്ടിയുള്ള ഏറ്റവും ജനപ്രിയമായ യൂട്ടിലിറ്റി സാധാരണമായ date കമാൻഡാണ്. ഇത് പ്രായോഗികമായി ഓരോ യൂണിക്സ്-ലൈക്ക് സിസ്റ്റത്തിലും ഉണ്ട്, പക്ഷേ ഒരു കുറുക്കുവഴിയുണ്ട്: ഇത് ഒരു യൂണിക്സ് ടൈംസ്റ്റാമ്പ് കൺവർട്ടറായി ഉപയോഗിക്കുന്നതിനുള്ള വാക്യശാസ്ത്രം ലിനക്സിലും (GNU) macOS-ലും (BSD) വ്യത്യസ്തമാണ്. എല്ലായ്പ്പോഴും ശരിയായി ലഭിക്കുന്നതിനുള്ള താക്കോലാണ് ഈ വ്യത്യാസം അറിയുന്നത്.
ലിനക്സിൽ ടൈംസ്റ്റാമ്പുകൾ പരിവർത്തനം ചെയ്യുന്നത്
ലിനക്സിൽ, വാക്യശാസ്ത്രം വ്യക്തവും ഓർക്കാൻ എളുപ്പവുമാണ്. നിങ്ങൾക്ക് തീയതി നിർദ്ദേശിക്കാൻ -d ഫ്ലാഗ് ഉപയോഗിക്കുക, പക്ഷേ നിങ്ങൾ ഒരു എപ്പോക്ക് ടൈംസ്റ്റാമ്പ് നൽകുന്നു എന്ന് അതിനോട് പറയേണ്ടതുണ്ട് @ ചിഹ്നം മുമ്പാകെ ചേർത്താണ്.
മനസ്സിലാക്കാം, നിങ്ങൾ ലോഗുകൾ പരിശോധിക്കുമ്പോൾ ടൈംസ്റ്റാമ്പ് 1704067200 കാണുന്നു എന്ന് സങ്കൽപ്പിക്കുക. അതിന്റെ യഥാർത്ഥ അർത്ഥം എന്താണെന്ന് അറിയാൻ, നിങ്ങൾ ഇത് പ്രവർത്തിപ്പിക്കണം:
date -d @1704067200
ഉടൻ തന്നെ, മനുഷ്യർക്ക് വായിക്കാവുന്ന ഒരു തീയതി നിങ്ങൾക്ക് ലഭിക്കും, ഇതുപോലെ Mon Jan 1 00:00:00 UTC 2024. ഈ ഔട്ട്പുട്ട് നിങ്ങളുടെ സ്വന്തം ഇഷ്ടാനുസൃത ഫോർമാറ്റ് ഉപയോഗിച്ച് വൃത്തിയാക്കാനും കഴിയും.
date -d @1704067200 +"%Y-%m-%d %H:%M:%S"
ഔട്ട്പുട്ട്: 2024-01-01 00:00:00
പ്രൊ ടിപ്പ്: മറ്റ് കമാൻഡുകൾ ഇതിലേക്ക് പൈപ്പ് ചെയ്യാൻ തുടങ്ങുമ്പോൾ ഈ കമാൻഡ് ഒരു ശരിക്കും ശക്തികേന്ദ്രമായി മാറുന്നു. ഒരു വലിയ ലോഗ് ഫയലിൽ നിന്ന്
grepഒരു ടൈംസ്റ്റാമ്പ് എടുത്ത് തത്സമയ പരിവർത്തനത്തിനായിdateലേക്ക് നേരിട്ട് കൈമാറാൻ കഴിയും. ഇത് ബഹു-ഘട്ട ഡീബഗിംഗ് ജോലിയെ ഒരൊറ്റ സുന്ദരമായ ഒറ്റവരിയാക്കി മാറ്റുന്നു.
macOS-ൽ പരിവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യുന്നു
ഇപ്പോൾ，ഈ ഒരേ ലിനക്സ് കമാൻഡ് മാക്കിൽ പ്രവർത്തിപ്പിച്ചാൽ，അത് പിശക് ഉണ്ടാക്കും. മാക്കോസ് ഉപയോഗിക്കുന്ന date ന്റെ ബിഎസ്ഡി പതിപ്പിന് പകരം -r ഫ്ലാഗ് ആവശ്യമാണ്，മാത്രമല്ല അതിന് @ മുൻനിബന്ധന ആവശ്യമില്ല.
മാക്കിൽ അതേ ടൈംസ്റ്റാമ്പ് എങ്ങനെ പരിവർത്തനം ചെയ്യാമെന്ന് ഇതാ:
date -r 1704067200
ലിനക്സ് പതിപ്പ് പോലെ，നിങ്ങൾക്ക് ആവശ്യമായ കൃത്യമായ ഔട്ട്പുട്ട് ലഭിക്കാൻ ഫോർമാറ്റിംഗ് ഓപ്ഷനുകൾ ചേർക്കാം.
date -r 1704067200 +"%Y-%m-%d %T %Z"
ഔട്ട്പുട്ട്: 2024-01-01 00:00:00 UTC
ലിനക്സും മാകോസും തമ്മിൽ ഇടയ്ക്കിടെ മാറുന്ന ആർക്കും ഈ ചെറിയ വ്യത്യാസം ഒരു സാധാരണ തടസ്സമാണ്. രണ്ട് പതിപ്പുകളും ഓർത്തുവെക്കുന്നത് ഭാവിയിൽ നിങ്ങളുടെ തലവേദന വലിയ അളവിൽ കുറയ്ക്കും.
നിങ്ങൾ ഈ കമാൻഡുകൾ വശമാക്കിയാൽ，നിങ്ങൾക്ക് ടൈംസ്റ്റാമ്പ് പരിവർത്തനങ്ങൾ നേരിട്ട് നിങ്ങളുടെ ഷെൽ സ്ക്രിപ്റ്റുകളിലും ലോഗ് വിശകലനത്തിലും സമന്വയിപ്പിക്കാം. ഇതൊരു ചെറിയ നൈപുണ്യമാണെങ്കിലും，ഗൗരവമേറിയ ഉൽപാദനക്ഷമതാ നേട്ടങ്ങളിലേക്ക് ഇത് ചേർത്തുവെക്കുന്നു，നിങ്ങളെ പ്രധാനപ്പെട്ട ജോലിയിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ സഹായിക്കുന്നു.
സാധാരണയായ ടൈംസ്റ്റാമ്പ് കുഴികളും അവയെ എങ്ങനെ ഒഴിവാക്കാമെന്നും
യൂണിക്സ് ടൈംസ്റ്റാമ്പുകളുമായി പ്രവർത്തിക്കുന്നത് പ്രാരംഭത്തിൽ ലളിതമായി തോന്നാമെങ്കിലും， കുറച്ച് ക്ലാസിക് തെറ്റുകൾ ചിലപ്പോൾ തികച്ചും അരിശപ്പെടുത്തുന്ന ബഗുകൾക്ക് കാരണമാകും. ഈ പ്രശ്നങ്ങൾക്ക്， എറർ യഥാർത്ഥത്തിൽ സംഭവിച്ച സ്ഥലത്ത് നിന്ന് വളരെ ദൂരെ പ്രത്യക്ഷപ്പെടാനുള്ള ഒരു ദുശ്ശീലമുണ്ട്， അത് ഡീബഗ് ചെയ്യാൻ യഥാർത്ഥത്തിൽ തലവേദന ഉണ്ടാക്കും. വർഷങ്ങളായി ഞാൻ കണ്ടിട്ടുള്ള ഏറ്റവും സാധാരണമായ ടൈംസ്റ്റാമ്പ് കുഴികളെ തിരിച്ചറിയുന്നതിനും ഒഴിവാക്കുന്നതിനും നിങ്ങളുടെ ഫീൽഡ് ഗൈഡ് ആയി ഈ വിഭാഗത്തെ കരുതുക.
സെക്കൻഡുകളും മില്ലിസെക്കൻഡുകളും തമ്മിലുള്ള കുഴപ്പം
ഇതുവരെ， ഏറ്റവും സാധാരണമായ തെറ്റ് സെക്കൻഡുകളെ മില്ലിസെക്കൻഡുകളുമായി കൂട്ടിക്കുഴയ്ക്കുന്നതാണ്. ഒരു സ്റ്റാൻഡേർഡ് യൂണിക്സ് ടൈംസ്റ്റാമ്പ്， ഇപ്പോച്ച് മുതൽ സെക്കൻഡുകളുടെ എണ്ണം സൂചിപ്പിക്കുന്ന ഒരു 10-അക്ഷര പൂർണ്ണസംഖ്യയാണ്. പക്ഷേ， പല സിസ്റ്റങ്ങളും， പ്രത്യേകിച്ച് ജാവസ്ക്രിപ്റ്റ് ലോകത്ത്， മില്ലിസെക്കൻഡുകൾക്കായി 13-അക്ഷര ടൈംസ്റ്റാമ്പുകളുമായി പ്രവർത്തിക്കുന്നു. ഒരു ഫ്രണ്ട്-എൻഡ് ആപ്പ് സെക്കൻഡുകൾ പ്രതീക്ഷിക്കുന്ന ബാക്കെൻഡിലേക്ക് ഒരു മില്ലിസെക്കൻഡ് മൂല്യം കൈമാറുമ്പോൾ， കാര്യങ്ങൾ തെറ്റാവും.
ഒരു unix timestamp convertor-ന്റെ അടുത്ത്， ആ 13-അക്ഷര നമ്പർ ശതാബ്ദങ്ങൾ ഭാവിയിലുള്ള ഒരു തീയതി പോലെ തോന്നും. ഇത് നിശ്ശബ്ദമായി ഡാറ്റ വാലിഡേഷൻ， ഷെഡ്യൂളിംഗ് ലോജിക്， നിങ്ങൾ സൂക്ഷിക്കാൻ ശ്രമിക്കുന്ന ഏതെങ്കിലും ചരിത്ര രേഖകൾ എന്നിവയെ തകർത്തേക്കാം. നിങ്ങൾ ആഴ്ചകൾക്ക് ശേഷവും ശ്രദ്ധിക്കാത്ത തരത്തിലുള്ള സൂക്ഷ്മമായ ഡാറ്റ കേടുപാടുകൾ ഇത് തന്നെയാണ്.
ടൈംസോൺ കുഴി
പരിചയസമ്പന്നരായ ഡവലപ്പർമാരെപ്പോലും കുടുക്കുന്ന മറ്റൊരു പിടിവിളിയാണ് സമയമേഖല കൈകാര്യം ചെയ്യൽ. തന്റെ സ്വഭാവം തന്നെയനുസരിച്ച്, ഒരു യൂണിക്സ് ടൈംസ്റ്റാമ്പ് എല്ലായ്പ്പോഴും കോർഡിനേറ്റഡ് യൂണിവേഴ്സൽ ടൈം (UTC) ലായിരിക്കും. ഇത് സ്ഥലത്തെ പൂർണ്ണമായും സ്വതന്ത്രമായ, ഒരു ഏകീകൃത, സാർവത്രിക നിമിഷത്തെ സൂചിപ്പിക്കുന്നു. ഇത് മറന്ന്, ഒരു ടൈംസ്റ്റാമ്പ് ഒരു ഉപയോക്താവിന്റെ പ്രാദേശിക സമയമാണെന്ന് തെറ്റിദ്ധരിച്ചാൽ കുടുക്ക് പ്രവർത്തിക്കും.
സമയമേഖല നിർദ്ദിഷ്ടമാക്കാതെ ഒരു ടൈംസ്റ്റാമ്പ് വായിക്കാവുന്ന തീയതിയാക്കി മാറ്റുമ്പോൾ ഈ തെറ്റ് സാധാരണയായി സംഭവിക്കും. നിങ്ങളുടെ സിസ്റ്റം പലപ്പോഴും സെർവറിന്റെ പ്രാദേശിക സമയത്തെ ഡീഫോൾട്ട് ആയി എടുക്കും, ഇത് അവ്യക്തത സൃഷ്ടിക്കുന്നു. ന്യൂയോർക്കിലുള്ള ഒരു ഉപയോക്താവ് ലണ്ടനിലുള്ള ഒരാൾക്ക് വേണ്ടി ഉദ്ദേശിച്ച സമയം കാണാം, പക്ഷേ അത് അനേകം മണിക്കൂർ വ്യത്യാസമുണ്ടായിരിക്കും.
സ്വർണ്ണ നിയമം ലളിതമാണ്: നിങ്ങളുടെ ബാക്കെൻഡിൽ എല്ലായ്പ്പോഴും ടൈംസ്റ്റാമ്പുകളെ UTC ആയി കണക്കാക്കുക. അവയെ UTC ആയി സംഭരിക്കുക, UTC ആയി പ്രോസസ് ചെയ്യുക, ഉപയോക്താവിന്റെ പ്രാദേശിക സമയത്തേക്ക് മാറ്റുന്നത് മുന്നിലെ അവസാനം, പ്രദർശനത്തിന്റെ നിമിഷത്തിൽ മാത്രം ചെയ്യുക.
സാധാരണ ടൈംസ്റ്റാമ്പ് രൂപാന്തരീകരണ തെറ്റുകൾ കൈകാര്യം ചെയ്യൽ
കാര്യങ്ങൾ തെറ്റിയാൽ, ലക്ഷണങ്ങൾ ആശയക്കുഴപ്പമുണ്ടാക്കാം. നിങ്ങൾക്ക് തത്സമയം ഏറ്റവും സാധാരണയായ പ്രശ്നങ്ങൾ നിർണ്ണയിക്കാനും പരിഹരിക്കാനും സഹായിക്കാൻ ഞാൻ അനുഭവത്തിൽ നിന്ന് തയ്യാറാക്കിയ ഒരു ദ്രുത റെഫറൻസ് ടേബിൾ ഇതാ.
| ലക്ഷണം | സാധ്യമായ കാരണം | പരിഹാരം |
|---|---|---|
| തീയതി 52361 അല്ലെങ്കിൽ മറ്റേതെങ്കിലും വിദൂര ഭാവിയിലെ വർഷത്തിലാണ്. | മില്ലിസെക്കൻഡുകൾ vs സെക്കൻഡുകൾ. ഒരു 10 അക്ഷര സെക്കൻഡ് ടൈംസ്റ്റാമ്പ് പ്രതീക്ഷിക്കുന്ന ഒരു ഫംഗ്ഷനിലേക്ക് നിങ്ങൾ ഒരു 13 അക്ഷര മില്ലിസെക്കൻഡ് ടൈംസ്റ്റാമ്പ് കൈമാറുകയാണ്. | പ്രോസസ്സ് ചെയ്യുന്നതിന് മുമ്പ് ടൈംസ്റ്റാമ്പിനെ 1000 കൊണ്ട് ഹരിക്കുക. വരുന്ന ടൈംസ്റ്റാമ്പുകളുടെ അക്ഷര എണ്ണം എല്ലായ്പ്പോഴും പരിശോധിക്കുക. |
| സമയം കുറച്ച് മണിക്കൂറുകൾ തെറ്റാണെങ്കിലും, തീയതി ശരിയാണ്. | ടൈംസോൺ തെറ്റായി കൈകാര്യം ചെയ്തത്. ഉപയോക്താവിന്റെയോ UTC യോടെയോ പകരം സെർവറിന്റെ ലോക്കൽ സമയം ഉപയോഗിച്ചാണ് ടൈംസ്റ്റാമ്പ് പരിവർത്തനം ചെയ്തത്. | എല്ലാ പരിവർത്തനങ്ങളിലും ലക്ഷ്യ ടൈംസോൺ വ്യക്തമായി സൂചിപ്പിക്കുന്നത് ഉറപ്പാക്കുക. ലോക്കൽ സമയത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നത് ക്ലയന്റ് വശത്ത് മാത്രം ചെയ്യുക. |
| തീയതി 1970 ജനുവരി 1 ലെ നിശ്ചലമാണ്. | അസാധുവായ അല്ലെങ്കിൽ ശൂന്യമായ ടൈംസ്റ്റാമ്പ്. ടൈംസ്റ്റാമ്പ് മൂല്യം സാധാരണയായി 0, null അല്ലെങ്കിൽ undefined. |
പരിവർത്തനം ശ്രമിക്കുന്നതിന് മുമ്പ് ടൈംസ്റ്റാമ്പ് ഒരു സാധുവായ നൽകാവുന്ന പൂർണ്ണ സംഖ്യയാണെന്ന് ഉറപ്പാക്കാൻ ഒരു പരിശോധന ചേർക്കുക. ഒരു ഫോൾബാക്ക് മൂല്യം നൽകുക. |
"അസാധുവായ തീയതി" അല്ലെങ്കിൽ NaN എറർ ലഭിക്കുന്നു. |
തെറ്റായ ഡേറ്റാ ടൈപ്പ്. ഒരു നമ്പർ ആവശ്യമുള്ളപ്പോൾ, ടൈംസ്റ്റാമ്പ് ഒരു സ്ട്രിംഗ് അല്ലെങ്കിൽ മറ്റൊരു നോൺ-ന്യൂമെറിക് ടൈപ്പായി പരിഗണിക്കപ്പെടുന്നു. | ഡേറ്റാ ഫംഗ്ഷനുകളിൽ ഉപയോഗിക്കുന്നതിന് മുമ്പ്, ടൈംസ്റ്റാമ്പിനെ വ്യക്തമായി ഒരു ഇൻറ്റജറാക്കി മാറ്റുക (parseInt() ജെഎസിലും, int() പൈത്തണിലും). |
ഓർക്കുക, ഇൻപുട്ടിനെക്കുറിച്ചുള്ള ഒരു പെട്ടെന്നുള്ള പരിശോധന പിന്നീട് നിങ്ങൾക്ക് മണിക്കൂറുകളുടെ ഡീബഗ്ഗിംഗ് ലാഭിക്കാൻ കഴിയും.
സ്റ്റാൻഡേർഡ് ഫോർമാറ്റുകൾ ഉപയോഗിച്ച് ആശയക്കുഴപ്പം ഒഴിവാക്കുക
സിസ്റ്റങ്ങൾക്കിടയിൽ ഡേറ്റാ കൈമാറുമ്പോൾ അസംസ്കൃത ഇൻറ്റജർ ടൈംസ്റ്റാമ്പുകളെ ആശ്രയിക്കുന്നത് ആശയക്കുഴപ്പത്തിനുള്ള ഒരു വിഭവമായിരിക്കാം. അതിനാലാണ് ISO 8601 (2022-05-17T12:00:00Z) പോലുള്ള സാർവത്രിക സ്ട്രിംഗ് ഫോർമാറ്റിൽ സ്റ്റാൻഡേർഡൈസ് ചെയ്യുന്നത് ഇത്രയും മികച്ച പ്രതിരോധ നീക്കമായിരിക്കുന്നത്. യൂണിക്സ് ടൈംസ്റ്റാമ്പുകൾ (ഉദാ: 1652905200) ഇതുപോലുള്ള വ്യക്തമായ, സ്വയം ഡോക്കുമെൻ്റേഷൻ ഫോർമാറ്റിലേക്ക് പരിവർത്തനം ചെയ്യുന്നത്, കണക്കാക്കപ്പെട്ട 37% ക്രോസ്-ടൈംസോൺ API കോളുകളിലെ എററുകൾ തടയാൻ സഹായിക്കുന്നു.
ഫോർച്ച്യൂൺ 500 കമ്പനികളിൽ 72% ലോഗ് വിശകലനത്തിനായി യൂണിക്സ് ടൈംസ്റ്റാമ്പുകൾ ഉപയോഗിക്കുന്നുവെന്ന് കണക്കിലെടുക്കുമ്പോൾ, അവിടെ ഒരു ചെറിയ അബദ്ധത്തിനുപോലും ഓരോ മണിക്കൂറിലും $10,000-യ്ക്ക് മുകളിൽ ഡൗൺടൈം നഷ്ടമാകാം, അതുകൊണ്ട് കൃത്യത എല്ലാമാണ്. വിവിധ വ്യവസായങ്ങളിൽ എപോക്ക് ടൈം എങ്ങനെ ഉപയോഗിക്കുന്നുവെന്നതിനെക്കുറിച്ച് നിങ്ങൾക്ക് EpochConverter.
വായിക്കാം.ഡാറ്റാബേസുകൾ നിയന്ത്രിക്കുന്നവർക്ക്, സ്ഥിരമായ ടൈംസ്റ്റാമ്പ് കൈകാര്യം ചെയ്യൽ അത്രയും നിർണായകമാണ്. നിങ്ങളുടെ ഡാറ്റാബേസിൽ വ്യത്യസ്ത ടൈംസ്റ്റാമ്പ് ഫോർമാറ്റുകളുമായി പതിവായി മല്ലടിക്കുന്നതായി നിങ്ങൾക്ക് തോന്നുകയാണെങ്കിൽ, ശക്തമായ SQL ഫോർമാറ്റർ ഉപയോഗിക്കുന്നതിനുള്ള ഞങ്ങളുടെ മാർഗ്ഗരേഖ നിങ്ങളുടെ ക്വെറികൾ വൃത്തിയും പ്രവചനാത്മകവുമായി സൂക്ഷിക്കാൻ സഹായിക്കും.
ഈ തീരുമാന മരം നിങ്ങളുടെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന് ശരിയായ കമാൻഡ് തിരഞ്ഞെടുക്കാൻ സഹായിക്കുന്നു, വേഗത്തിൽ ഒരു രൂപാന്തരം ആവശ്യമുള്ളപ്പോൾ രൂപസംഹാര പിശകുകൾ തടയുന്നു.
മുകളിലുള്ള ഫ്ലോചാർട്ട് വ്യക്തമായി കാണിക്കുന്നു date കമാൻഡിന്റെ ലിനക്സിലെ (-d @...) കമാൻഡിന്റെ മാക്ക്ഓഎസ്സിലെ (-r ...) തമ്മിലുള്ള പ്രധാന സിന്റാക്സ് വ്യത്യാസം—വ്യത്യസ്ത എൻവയോൺമെന്റുകളിൽ ജോലി ചെയ്യുന്ന ഡവലപ്പർമാരെ സംബന്ധിച്ച് ഒരു സാധാരണ തടസ്സം.
നിങ്ങളുടെ കോഡ് സുരക്ഷിതമാക്കാൻ, ഒരു ഇൻകമിംഗ് ടൈംസ്റ്റാമ്പിന്റെ നീളം പരിശോധിക്കുന്നതിനുള്ള പരിശോധനകൾ എല്ലായ്പ്പോഴും നടപ്പാക്കുക. 10-അക്ക (സെക്കൻഡ്) അല്ലെങ്കിൽ 13-അക്ക (മില്ലിസെക്കൻഡ്) മൂല്യം പരിശോധിക്കുന്ന ഒരു ലളിതമായ ഫംഗ്ഷൻ ഈ പിശകുകൾ നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ ലോജിക് മലിനമാക്കുന്നതിന് മുമ്പ് തന്നെ പിടിക്കാൻ കഴിയും.
യൂണിക്സ് ടൈംസ്റ്റാമ്പുകളെക്കുറിച്ചുള്ള സാധാരണ ചോദ്യങ്ങൾ
യൂണിക്സ് ടൈംസ്റ്റാമ്പുകൾ മനസ്സിലാക്കിക്കഴിഞ്ഞാൽ, കുറച്ച് പ്രായോഗിക ചോദ്യങ്ങൾ ഏതാണ്ട് എപ്പോഴും ഉയർന്നുവരും. എല്ലാ തലത്തിലുള്ള ഡവലപ്പർമാരെയും ഇത് കുഴപ്പത്തിലാക്കുന്നത് ഞാൻ കണ്ടിട്ടുണ്ട്, അതിനാൽ നിങ്ങളുടെ ദൈനംദിന ജോലിയിൽ നേരിടുന്ന ഏറ്റവും സാധാരണയായവയെക്കുറിച്ച് നമുക്ക് വ്യക്തത വരുത്താം.
എന്തുകൊണ്ടാണ് ഇത്രയധികം API-കൾ ISO 8601 സ്ട്രിംഗുകൾക്ക് പകരം ടൈംസ്റ്റാമ്പുകൾ ഉപയോഗിക്കുന്നത്?
അത് യഥാർത്ഥത്തിൽ അസംസ്കൃത കാര്യക്ഷമതയെയാണ് ആശ്രയിക്കുന്നത്. യൂണിക്സ് ടൈംസ്റ്റാമ്പ് ഒരൊറ്റ നമ്പർ മാത്രമാണ്, അതുകൊണ്ട് തന്നെ ''2023-10-27T10:00:00Z'' പോലുള്ള ഒരു സ്ട്രിങ്ങിനെക്കാൾ അത് അതിശയകരമാംവിധം ചെറുതാണ്. ആ ചെറിയ വലിപ്പം വയർ മുഖേന അയക്കേണ്ട കുറച്ച് ഡാറ്റ എന്ന് അർത്ഥമാക്കുന്നു, അത് ബാൻഡ്വിഡ്ത് ലാഭിക്കുകയും API പ്രതികരണങ്ങളെ വേഗത്തിലാക്കുകയും ചെയ്യും.
ഇവ പൂർണ്ണമായും ഭാഷാ-നിരപേക്ഷമാണ്. ഇവയ്ക്ക് അവ്യക്തതയോ, പാർസിംഗ് പ്രശ്നങ്ങളോ, പ്രാദേശിക ഫോർമാറ്റിംഗ് പ്രശ്നങ്ങളോ ഇല്ല. ഒരു മെഷീന്, സ്ട്രിംഗുകൾ പാർസ് ചെയ്യുന്നതിനേക്കാൾ എപ്പോഴും വേഗത്തിൽ സംഖ്യകൾ ക്രഞ്ച് ചെയ്യാൻ കഴിയും, അതിനാൽ ഏതൊക്കെയും തീയതി കണക്കുകൾ — രണ്ട് സംഭവങ്ങൾ തമ്മിലുള്ള സമയം കണ്ടെത്തുക പോലുള്ളവ — കമ്പ്യൂട്ടേഷണൽ ലൈറ്റ് ആയിരിക്കും. ഹൈ-പെർഫോമൻസ് സിസ്റ്റങ്ങൾക്ക്, ആ ലാളിത്യം വലിയൊരു നേട്ടമാണ്.
സമയ മേഖലകൾ ശരിയായ രീതിയിൽ കൈകാര്യം ചെയ്യുന്നത് എങ്ങനെയാണ്?
ഇത് തന്നെയാണ് ഏറ്റവും പ്രധാന കാര്യം. ഇതാണ് സ്വർണ്ണ നിയമം: ഒരു യൂണിക്സ് ടൈംസ്റ്റാമ്പ് എപ്പോഴും, എപ്പോഴും UTC-യിൽ ആയിരിക്കും. അതിൽ സമയ മേഖല എന്ന ആശയം ഉൾച്ചേർത്തിട്ടില്ല. അത് വെറും ഒരു എപ്പോച്ചിൽ നിന്നുള്ള സെക്കൻഡുകളുടെ അസംസ്കൃത എണ്ണം മാത്രമാണ്.
ആ ടൈംസ്റ്റാമ്പ് ഒരു മനുഷ്യന് കാണിക്കേണ്ടി വരുമ്പോൾ മാത്രമേ സമയ മേഖലകൾ പ്രധാനമാകൂ.
എൻറെ ഉപദേശം? ബാക്കെൻഡിലെ എല്ലാറ്റിനും UTC ഉപയോഗിക്കുന്നത് തുടരുക. അത് നിങ്ങളുടെ ഡേറ്റാബേസിൽ ഒരു UTC ടൈംസ്റ്റാമ്പ് ആയി സൂക്ഷിക്കുക, നിങ്ങളുടെ API-കളിലൂടെ UTC-യിൽ കൈമാറുക, എല്ലാ സെർവർ-സൈഡ് ലോജിക്കും UTC-യിൽ തന്നെ ചെയ്യുക. അത് ഒരു പ്രാദേശിക സമയ മേഖലയിലേക്ക് മാറ്റേണ്ടി വരുന്ന ഏകയായ സമയം മുൻപ് ഉപയോക്താവിന് കാണിക്കുന്നതിന് തൊട്ടുമുമ്പ് ഫ്രണ്ട്-എൻഡിൽ മാത്രമായിരിക്കണം. ഈ ഒരൊറ്റ രീതി, സമയ മേഖലയുമായും ഡേലൈറ്റ് സേവിംഗുമായും ബന്ധമുള്ള നിരവധി പിശകുകളിൽ നിന്ന് നിങ്ങളെ രക്ഷിക്കും.
എനിക്ക് ഇപ്പോഴും 2038 പ്രശ്നത്തെക്കുറിച്ച് ആശങ്കപ്പെടണോ?
പുതിയ പ്രോജക്റ്റുകൾക്കായി, സാധാരണയായി അത് ആവശ്യമില്ല. "2038 വർഷ പ്രശ്നം" എന്നത് ടൈംസ്റ്റാമ്പ് സൂക്ഷിക്കാൻ 32-ബിറ്റ് സൈൻഡ് ഇന്റിജർ ഉപയോഗിച്ചിരുന്ന പഴയ സിസ്റ്റങ്ങളുടെ ഒരു അവശിഷ്ടമാണ്. ആ നമ്പർ വലുതാകുമ്പോൾ, അത് റാപ്പ് ചെയ്ത് നെഗറ്റീവ് ആകുന്നു, തീയതികൾ 1901-ലേക്ക് തിരിച്ചുവിടുന്നു.
ഭാഗ്യവശാൽ, ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ മുതൽ ഡാറ്റാബേസുകൾ വരെ — ഏകദേശം എല്ലാ ആധുനിക സിസ്റ്റങ്ങളും നിങ്ങൾക്ക് അറിയാവുന്നതുപോലെ 64-ബിറ്റ് ഇന്റിജറുകളിലേക്ക് മാറിയിട്ടുണ്ട്. ഇത് കാൻ വളരെ ദൂരെയായി തള്ളിവയ്ക്കുന്നു (യഥാർത്ഥത്തിൽ ബില്യൺ കൊല്ലങ്ങൾ), അതിനാൽ ഇത് ഇനി നമുക്ക് പ്രായോഗിക പ്രശ്നമല്ല.
ഇത് പറയുമ്പോഴും, നിങ്ങൾ ഒരു ലെഗസി സിസ്റ്റം നിലനിർത്തുകയോ എംബഡഡ് ഹാർഡ്വെയറുമായി പ്രവർത്തിക്കുകയോ ചെയ്യുന്നുണ്ടെങ്കിൽ (ഐഒടി ഉപകരണങ്ങൾ ചിന്തിക്കുക), ഇത് തീർച്ചയായും ശ്രദ്ധിക്കേണ്ട കാര്യമാണ്. നിങ്ങൾ ഏത് തരം ആർക്കിടെക്ചറിന്റെ മുകളിലാണ് ബിൽഡ് ചെയ്യുന്നതെന്ന് എല്ലായ്പ്പോഴും അറിയുക.
എക്സെലിലോ ഗൂഗിൾ ഷീറ്റിലോ ഒരു ടൈംസ്റ്റാമ്പ് ഞാൻ എങ്ങനെ ദ്രുതമായി പരിവർത്തനം ചെയ്യാം?
ഇതിനായി നിങ്ങളുടെ ഡാറ്റ വേറൊരു യൂണിക്സ് ടൈംസ്റ്റാമ്പ് കൺവെർട്ടറിലേക്ക് എടുക്കേണ്ടതില്ല. ഒരു ലളിതമായ ഫോർമുല കൊണ്ട് അത് ചെയ്യാം. നിങ്ങളുടെ ടൈംസ്റ്റാമ്പ് A1 സെല്ലിലാണെന്ന് കരുതിയാൽ:
- സെക്കൻഡുകളിലുള്ള ടൈംസ്റ്റാമ്പുകൾക്കായി (10 അക്ഷരങ്ങൾ):
=A1 / 86400 + DATE(1970,1,1) - മില്ലിസെക്കൻഡുകളിലുള്ള സമയമുദ്രകൾക്ക് (13 അക്ഷരങ്ങൾ):
=A1 / 86400000 + DATE(1970,1,1)
ആ ഫോർമുല ഇടുക, തുടർന്ന് സെല്ലിനെ "തീയതി" അല്ലെങ്കിൽ "തീയതി സമയം" എന്ന് ഫോർമാറ്റ് ചെയ്യുക. ഡേറ്റ എക്സ്പോർട്ടുകൾ വേഗത്തിൽ വിശകലനം ചെയ്യുമ്പോൾ നിങ്ങളുടെ ഫ്ലോ തടസ്സപ്പെടുത്താൻ താല്പര്യമില്ലാത്തപ്പോൾ ഇത് ഒരു രക്ഷാകവചമാണ്.
ലഘുവായ ജോലികൾക്കായി നിങ്ങളുടെ എഡിറ്റർ, കമാൻഡ് ലൈൻ, ഒരു ഡസൻ ബ്രൗസർ ടാബുകൾ എന്നിവയ്ക്കിടയിൽ നിരന്തരം മാറുന്നത് മടുത്തോ? ShiftShift Extensions സ്യൂട്ട് ഒരു ശക്തമായ യൂണിക്സ് ടൈംസ്റ്റാമ്പ് കൺവെർട്ടർ, JSON ഫോർമാറ്റർ, SQL ബ്യൂട്ടിഫയർ എന്നിവയെല്ലാം നിങ്ങളുടെ ബ്രൗസറിലേക്ക് തന്നെ ബണ്ടിൾ ചെയ്യുന്നു. നിങ്ങൾക്ക് ആവശ്യമായ എല്ലാം ഒരു കീബോർഡ് ഷോർട്ട്കട്ട് അകലെയാണ്.
ഇന്ന് തന്നെ ShiftShift Extensions നേടൂ, നിങ്ങളുടെ വർക്ക്ഫ്ലോ ലളിതമാക്കൂ https://shiftshift.app