Unix Timestamp സെക്കൻഡ് vs മില്ലിസെക്കൻഡ്: തീയതി എന്തുകൊണ്ട് 1970 കാണിക്കുന്നു

timestamp തീയതിയാക്കി ജനുവരി 1970യിൽ എത്തി. ക്ലോക്ക് അപൂർവമായേ തകരാറാകൂ. സംഖ്യ സെക്കൻഡായി സൂക്ഷിച്ചപ്പോൾ മില്ലിസെക്കൻഡായി വായിച്ചു—അല്ലെങ്കിൽ തിരിച്ചും.

Unix timestamp എന്താണ്?

Unix timestamp സമയം Unix epoch മുതൽ അളക്കുന്നു: 1970-01-01 00:00:00 UTC. സാധാരണ പൂർണ്ണ സെക്കൻഡ്. അതേ നിമിഷം മില്ലിസെക്കൻഡായും സൂക്ഷിക്കാം (സെക്കൻഡ് × 1,000). സംഖ്യ തന്നെ യൂണിറ്റ് പറയുന്നില്ല.

സെക്കൻഡ് vs മില്ലിസെക്കൻഡ്: 1,000 മടങ്ങ് വ്യത്യാസം

ഒരു സെക്കൻഡ് 1,000 മില്ലിസെക്കൻഡ്. 1720000000നെ 1720000000000യുമായി താരതമ്യം ചെയ്യുക. ആദ്യത്തേത് സെക്കൻഡ്, രണ്ടാമത്തേത് മില്ലിസെക്കൻഡ് എങ്കിൽ അതേ നിമിഷം. ആദ്യത്തേത് മില്ലിസെക്കൻഡായി വായിച്ചാൽ തീയതി 1970 ഭാഗത്തേക്ക് ചാടും.

ഈ UTC ഫലങ്ങൾ മുകളിലെ സംഖ്യകളിൽ നിന്ന് കണക്കാക്കിയതാണ്, ഊഹമല്ല.

മൂല്യം	സാധ്യമായ യൂണിറ്റ്	വ്യാഖ്യാനം (UTC)
1720000000	സെക്കൻഡ്	സെക്കൻഡായി വായിച്ചാൽ ആധുനിക തീയതി: 2024-07-03 09:46:40 UTC
1720000000000	മില്ലിസെക്കൻഡ്	മില്ലിസെക്കൻഡായി വായിച്ചാൽ അതേ നിമിഷം: 2024-07-03 09:46:40 UTC
1720000000 മില്ലിസെക്കൻഡായി	തെറ്റായ യൂണിറ്റ്	1970ക്കടുത്ത തീയതി: 1970-01-20 21:46:40 UTC

എന്റെ timestamp എന്തുകൊണ്ട് 1970 കാണിക്കുന്നു?

സെക്കൻഡ് മൂല്യം മില്ലിസെക്കൻഡായി കണക്കാക്കിയാൽ സംഖ്യ വേണ്ടതിനേക്കാൾ 1,000 മടങ്ങ് ചെറുത്. JavaScript അപ്പോൾ Unix epochിന് ശേഷം ചെറിയ ഇടവേള മാത്രം എണ്ണുന്നു, തീയതി 1970യിൽ നിൽക്കും:

const seconds = 1720000000;

new Date(seconds);
// 1970-01-20 21:46:40 UTC

new Date(seconds * 1000);
// 2024-07-03 09:46:40 UTC

ആ 1970 തീയതി epoch പ്ലസ് ഏകദേശം രണ്ട് ആഴ്ച. Dateന് കൊടുക്കുന്നതിന് മുമ്പ് സെക്കൻഡ് 1,000 കൊണ്ട് ഗുണിക്കുക.

• സെക്കൻഡ്
• 1720000000
• × 1000
• ↓
• മില്ലിസെക്കൻഡ്
• 1720000000000

• സെക്കൻഡ് മൂല്യം
• ↓
• തെറ്റായി മില്ലിസെക്കൻഡായി കണക്കാക്കി
• ↓
• 1970ക്കടുത്ത തീയതി

10 അക്കം സെക്കൻഡോ, 13 മില്ലിസെക്കൻഡോ?

ആധുനിക തീയതികളിൽ 10 അക്കം പലപ്പോഴും സെക്കൻഡ്, 13 പലപ്പോഴും മില്ലിസെക്കൻഡ്. ഇത് വേഗത്തിലുള്ള സൂചനയാണ്, സാധൂകരണ നിയമമല്ല. അക്കങ്ങളുടെ എണ്ണം കാലപരിധിയനുസരിച്ച് മാറും; ചില API മൈക്രോസെക്കൻഡ് അല്ലെങ്കിൽ നാനോസെക്കൻഡ് സൂക്ഷിക്കുന്നു. യൂണിറ്റ് ഡോക്യുമെന്റേഷൻ അല്ലെങ്കിൽ അർത്ഥമുള്ള തീയതി കൊണ്ട് ഉറപ്പാക്കുക.

ഇത് JavaScript-ൽ എന്തുകൊണ്ട് ഇത്ര പലപ്പോഴും സംഭവിക്കുന്നു

JavaScript-ൽ സംഖ്യാ Date epoch മുതൽ മില്ലിസെക്കൻഡ്. പല ബാക്കെൻഡുകളും ഡാറ്റാബേസുകളും Unix ടൂളുകളും ഇപ്പോഴും സെക്കൻഡ് സൂക്ഷിക്കുന്നു. സെക്കൻഡ് നേരിട്ട് Dateന് കൊടുക്കുന്നത് സാധാരണ തെറ്റ്:

const unixSeconds = 1720000000;

const wrong = new Date(unixSeconds);
const correct = new Date(unixSeconds * 1000);

wrong 1970ക്കടുത്ത് (1970-01-20 21:46:40 UTC). correct ആധുനിക നിമിഷം (2024-07-03 09:46:40 UTC).

മറ്റ് സിസ്റ്റങ്ങൾ വ്യത്യസ്ത യൂണിറ്റുകൾ ഉപയോഗിക്കുന്നു

മറ്റ് ഭാഷകൾ, API, ഡാറ്റാബേസുകൾ സെക്കൻഡ് അല്ലെങ്കിൽ മില്ലിസെക്കൻഡ് ഉപയോഗിച്ചേക്കാം. ചിലത് മൈക്രോസെക്കൻഡ് അല്ലെങ്കിൽ നാനോസെക്കൻഡ് സൂക്ഷിക്കുന്നു. ഒരു ഭാഷ എപ്പോഴും ഒരേ യൂണിറ്റ് ഉപയോഗിക്കുമെന്ന് കരുതരുത്—ഡോക്യുമെന്റേഷൻ നോക്കുക. സംഖ്യ JSON-ൽ ആണെങ്കിൽ JSON ക്രമീകരിക്കുക / Diff ഫീൽഡ് വായിക്കാൻ സഹായിക്കും; യൂണിറ്റ് പറയില്ല.

എന്റെ timestamp ഏത് യൂണിറ്റ് എന്ന് എങ്ങനെ അറിയാം?

ഈ പരിശോധനകൾ ക്രമത്തിൽ ചെയ്യുക. അക്കങ്ങളുടെ എണ്ണം മാത്രം പോരാ.

1. API അല്ലെങ്കിൽ ഡാറ്റാബേസ് ഡോക്യുമെന്റേഷൻ നോക്കുക.
2. ഏകദേശ അക്കങ്ങളുടെ എണ്ണം നോക്കുക.
3. മൂല്യത്തെ വിശ്വസനീയമായ ആധുനിക timestampയുമായി താരതമ്യം ചെയ്യുക.
4. മൂല്യം സെക്കൻഡായും മില്ലിസെക്കൻഡായും പരീക്ഷിക്കുക.
5. കിട്ടിയ തീയതി അർത്ഥമുള്ളതാണോ നോക്കുക.

ഒരു വ്യാഖ്യാനം 1970യിൽ വീഴുകയും മറ്റേത് നിങ്ങൾക്കറിയാവുന്ന തീയതിയിൽ വീഴുകയും ചെയ്താൽ, കാരണം യൂണിറ്റ് പൊരുത്തക്കേട്.

Unix timestamp സാധാരണ തെറ്റുകൾ

• സെക്കൻഡ് മില്ലിസെക്കൻഡായി വ്യാഖ്യാനിക്കൽ. തീയതി 1970 ഭാഗത്തേക്ക് ചുരുങ്ങുന്നു, മുകളിലെ ഉദാഹരണം പോലെ.
• മില്ലിസെക്കൻഡ് സെക്കൻഡായി വ്യാഖ്യാനിക്കൽ. തീയതി ദൂര ഭാവിയിലേക്ക് ചാടുന്നു, അല്ലെങ്കിൽ പരിവർത്തനം പരാജയപ്പെടുന്നു.
• 1,000 കൊണ്ട് രണ്ടുതവണ ഗുണിക്കൽ. ഇതിനകം മില്ലിസെക്കൻഡായിരുന്ന മൂല്യം വലുതായി തീയതി നൂറ്റാണ്ടുകൾ മുന്നോട്ട് പോകുന്നു.
• 1,000 കൊണ്ട് രണ്ടുതവണ ഹരിക്കൽ. സെക്കൻഡ് മൂല്യം വീണ്ടും ചുരുങ്ങുന്നു, വീണ്ടും 1970ക്കടുത്ത്.
• സമയ മേഖലയെ കുറ്റപ്പെടുത്തൽ. മേഖല മണിക്കൂറുകളോ കലണ്ടർ ദിവസമോ മാറ്റാം. ആധുനിക timestampനെ 1970 ആക്കുന്നില്ല.
• ഫോർമാറ്റ് ചെയ്ത തീയതിയെ Unix timestamp ആയി കാണൽ. 2024-07-03T09:46:40Z പോലുള്ള മൂല്യം epoch സംഖ്യയല്ല. സെക്കൻഡായിട്ടല്ല, തീയതിയായി പാഴ്‌സ് ചെയ്യുക.

സമയ മേഖല 1970 പ്രശ്നം ഉണ്ടാക്കുന്നുണ്ടോ?

സാധാരണയായി ഇല്ല. സമയ മേഖല കാണിക്കുന്ന ക്ലോക്ക് മാറ്റാം, അർധരാത്രിക്കടുത്ത് കലണ്ടർ തീയതിയും. ആധുനിക Unix timestampനെ 1970 ആക്കുന്നില്ല. ഫലം 1970 ആണെങ്കിൽ ആദ്യം സെക്കൻഡ് vs മില്ലിസെക്കൻഡ് നോക്കുക.

Unix timestamp പരിവർത്തനം ചെയ്ത് പരിശോധിക്കുക

NEXNARA തീയതി-സമയ പരിവർത്തകൻ ബ്രൗസറിൽ Unix timestamp പരിവർത്തനം ചെയ്യാം.

Unix സെക്കൻഡ് അല്ലെങ്കിൽ മില്ലിസെക്കൻഡ് ഒട്ടിക്കുക, നിലവിലെ timestamp ഉപയോഗിക്കുക, UTCയും പ്രാദേശിക സമയവും കാണുക, മേഖലകൾ മാറ്റുക, തീയതി ഫോർമാറ്റ് ചെയ്യുക. സ്വയം കണ്ടെത്തൽ പലപ്പോഴും 10 അക്കത്തെ സെക്കൻഡായും 13നെ മില്ലിസെക്കൻഡായും കാണും; യൂണിറ്റ് നിങ്ങൾക്ക് ഇനിയും തിരഞ്ഞെടുക്കാം.

പരിവർത്തനം തന്നെ നിങ്ങളുടെ ബ്രൗസറിൽ നടക്കുന്നു. ഈ ടൂൾ തീയതികളോ timestampsഓ NEXNARA സെർവറിലേക്ക് അയയ്ക്കുന്നില്ല. പരസ്യങ്ങളും മറ്റ് സൈറ്റ് സവിശേഷതകളും ഇപ്പോഴും നെറ്റ്‌വർക്ക് ഉപയോഗിക്കുന്നു; അത് പരിവർത്തനത്തിൽ നിന്ന് വേറെയാണ്.

Unix timestamp പരിശോധിക്കണോ? തീയതി-സമയ പരിവർത്തകൻ തുറന്ന് സെക്കൻഡ് മില്ലിസെക്കൻഡുമായി താരതമ്യം ചെയ്യുക.

FAQ

എന്റെ Unix timestamp എന്തുകൊണ്ട് 1970 കാണിക്കുന്നു?

പലപ്പോഴും മില്ലിസെക്കൻഡായി വായിച്ച സെക്കൻഡ്. JavaScript വളരെ ചെറിയ സംഖ്യ കൈകാര്യം ചെയ്യുന്നു, തീയതി 1970-01-01 00:00:00 UTCന് ശേഷം ഇരിക്കും. സെക്കൻഡ് 1,000 കൊണ്ട് ഗുണിച്ച് വീണ്ടും പരിവർത്തനം ചെയ്യുക.

Unix timestamps സെക്കൻഡോ മില്ലിസെക്കൻഡോ?

സാധാരണ സെക്കൻഡ്. പല വെബ് APIകളും JavaScript Dateഉം മില്ലിസെക്കൻഡ് ഉപയോഗിക്കുന്നു. ആ സിസ്റ്റം എന്ത് ഡോക്യുമെന്റ് ചെയ്യുന്നു എന്ന് എപ്പോഴും നോക്കുക. ചിലത് മൈക്രോസെക്കൻഡ് അല്ലെങ്കിൽ നാനോസെക്കൻഡ് ഉപയോഗിക്കുന്നു.

സെക്കൻഡ് മില്ലിസെക്കൻഡാക്കി എങ്ങനെ മാറ്റാം?

1,000 കൊണ്ട് ഗുണിക്കുക. 1720000000 സെക്കൻഡ് 1720000000000 മില്ലിസെക്കൻഡ്. മറുഭാഗത്ത് 1,000 കൊണ്ട് ഹരിക്കുക.

JavaScript Date എന്തുകൊണ്ട് മില്ലിസെക്കൻഡ് ഉപയോഗിക്കുന്നു?

JavaScript-ൽ Dateന്റെ സംഖ്യാ timestamp Unix epoch മുതൽ മില്ലിസെക്കൻഡായി നിർവചിച്ചിരിക്കുന്നു. അതുകൊണ്ട് unixSeconds Unix സെക്കൻഡ് ആണെങ്കിൽ new Date(unixSeconds) തെറ്റാണ്.

10 അക്ക timestamp എപ്പോഴും സെക്കൻഡാണോ?

അല്ല. ആധുനിക തീയതികളിൽ പലപ്പോഴും സെക്കൻഡ്, 13 അക്കം പലപ്പോഴും മില്ലിസെക്കൻഡ്. അക്കങ്ങളുടെ എണ്ണം സൂചനയാണ്, നിയമമല്ല. ഡോക്യുമെന്റേഷൻ അല്ലെങ്കിൽ അർത്ഥമുള്ള തീയതി കൊണ്ട് ഉറപ്പാക്കുക.

Unix timestamp-ൽ സമയ മേഖല ഉണ്ടോ?

ഇല്ല. Unix timestamp 1970-01-01 00:00:00 UTC മുതൽ എണ്ണിയ ഒരു നിമിഷമാണ്. സമയ മേഖലകൾ പ്രദർശനം മാറ്റുന്നു, സംഖ്യയെ അല്ല.