Unix Timestamp în secunde vs milisecunde: de ce data arată 1970

Ați convertit un timestamp și ați ajuns în ianuarie 1970. Ceasul e rar stricat. Numărul a fost citit ca milisecunde deși era stocat în secunde—sau invers.

Ce este un Unix timestamp?

Un Unix timestamp măsoară timpul de la Unix epoch: 1970-01-01 00:00:00 UTC. Folosește de obicei secunde întregi. Același moment poate fi stocat și în milisecunde (secunde × 1.000). Numărul însuși nu indică unitatea.

Secunde vs milisecunde: diferența ×1.000

O secundă înseamnă 1.000 de milisecunde. Comparați 1720000000 cu 1720000000000. Dacă primul e în secunde și al doilea în milisecunde, e același moment. Citiți primul ca milisecunde și data sare spre 1970.

Aceste rezultate UTC sunt calculate din numerele de mai sus, nu estimate.

Valoare	Unitate probabilă	Interpretare (UTC)
1720000000	Secunde	Dată modernă citită ca secunde: 2024-07-03 09:46:40 UTC
1720000000000	Milisecunde	Același moment citit ca milisecunde: 2024-07-03 09:46:40 UTC
1720000000 ca milisecunde	Unitate greșită	Dată aproape de 1970: 1970-01-20 21:46:40 UTC

De ce timestamp-ul meu arată 1970?

Dacă o valoare în secunde e tratată ca milisecunde, numărul e de 1.000 de ori prea mic. JavaScript numără atunci doar un interval scurt după Unix epoch, iar data rămâne în 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

Acea dată din 1970 e epoch plus cam două săptămâni. Înmulțiți secundele cu 1.000 înainte să le dați lui Date.

• SECUNDE
• 1720000000
• × 1000
• ↓
• MILISECUNDE
• 1720000000000

• Valoare în secunde
• ↓
• Tratată greșit ca milisecunde
• ↓
• Dată aproape de 1970

10 cifre sunt secunde și 13 milisecunde?

Pentru datele de azi, 10 cifre sunt adesea secunde, iar 13 adesea milisecunde. E un indiciu rapid, nu o regulă de validare. Numărul de cifre se schimbă cu intervalul de timp, iar unele API stochează microsecunde sau nanosecunde. Confirmați unitatea din documentație sau dintr-o dată care are sens.

De ce se întâmplă atât de des în JavaScript

În JavaScript, un Date numeric e în milisecunde de la epoch. Multe backend-uri, baze și unelte Unix încă stochează secunde. A da o valoare în secunde direct lui Date e o greșeală frecventă:

const unixSeconds = 1720000000;

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

wrong e aproape de 1970 (1970-01-20 21:46:40 UTC). correct e momentul modern (2024-07-03 09:46:40 UTC).

Alte sisteme folosesc alte unități

Alte limbaje, API-uri și baze pot folosi secunde sau milisecunde. Unele stochează microsecunde sau nanosecunde. Nu presupuneți că un limbaj folosește mereu o unitate—citiți documentația. Dacă numărul e în JSON, Formatare și comparare JSON face câmpul lizibil; tot nu vă spune unitatea.

Cum aflu ce unitate folosește timestamp-ul meu?

Parcurgeți aceste verificări în ordine. Numărul de cifre singur nu ajunge.

1. Verificați documentația API-ului sau a bazei de date.
2. Uitați-vă la numărul aproximativ de cifre.
3. Comparați valoarea cu un timestamp modern plauzibil.
4. Testați valoarea ca secunde și ca milisecunde.
5. Verificați dacă data rezultată are sens.

Dacă o interpretare cade în 1970 și cealaltă pe o dată pe care o recunoașteți, cauza e nepotrivirea de unitate.

Greșeli obișnuite cu Unix timestamp

• Secunde interpretate ca milisecunde. Data se prăbușește spre 1970, ca în exemplul de mai sus.
• Milisecunde interpretate ca secunde. Data sare departe în viitor, sau conversia eșuează.
• Înmulțire cu 1.000 de două ori. O valoare deja în milisecunde devine uriașă și data sare secole înainte.
• Împărțire la 1.000 de două ori. O valoare în secunde se micșorează din nou, din nou aproape de 1970.
• A da vina pe fusul orar. Un fus poate muta orele sau ziua calendaristică. Nu duce un timestamp modern în 1970.
• A trata un șir de dată formatat ca Unix timestamp. O valoare ca 2024-07-03T09:46:40Z nu e un număr epoch. Parsați-o ca dată, nu ca secunde.

Fusul orar cauzează problema 1970?

De obicei, nu. Un fus poate schimba ceasul afișat și, aproape de miezul nopții, data calendaristică. Nu transformă un Unix timestamp modern în 1970. Dacă rezultatul e 1970, verificați mai întâi secunde versus milisecunde.

Convertiți și verificați un Unix timestamp

NEXNARA Convertor dată și oră poate converti un Unix timestamp în browser.

Lipiți secunde sau milisecunde Unix, folosiți timestamp-ul curent, vedeți UTC și ora locală, convertiți fusuri și formatați o dată. Detectarea automată tratează adesea 10 cifre ca secunde și 13 ca milisecunde; puteți totuși alege unitatea.

Conversia însăși se face în browser. Instrumentul nu trimite date sau timestamp-uri către un server NEXNARA. Reclamele și alte funcții ale site-ului folosesc în continuare rețeaua; asta e separat de conversie.

Trebuie să verificați un Unix timestamp? Deschideți Convertor dată și oră și comparați secundele cu milisecundele.

FAQ

De ce Unix timestamp-ul meu arată 1970?

Adesea sunt secunde citite ca milisecunde. JavaScript tratează un număr mult mai mic, deci data cade imediat după 1970-01-01 00:00:00 UTC. Înmulțiți secundele cu 1.000 și convertiți din nou.

Unix timestamp-urile sunt secunde sau milisecunde?

De obicei secunde. Multe API-uri web și Date în JavaScript folosesc milisecunde. Verificați întotdeauna ce documentează sistemul. Unele sisteme folosesc microsecunde sau nanosecunde.

Cum convertesc secundele în milisecunde?

Înmulțiți cu 1.000. 1720000000 secunde sunt 1720000000000 milisecunde. În sens invers, împărțiți la 1.000.

De ce Date în JavaScript folosește milisecunde?

Timestamp-ul numeric Date din JavaScript e definit ca milisecunde de la Unix epoch. De aceea new Date(unixSeconds) e greșit când unixSeconds sunt secunde Unix.

Un timestamp de 10 cifre e întotdeauna în secunde?

Nu. Pentru datele de azi e adesea așa, iar 13 cifre sunt adesea milisecunde. Numărul de cifre e un indiciu, nu o regulă. Confirmați cu documentație sau o dată care are sens.

Un Unix timestamp conține fus orar?

Nu. Un Unix timestamp e un moment numărat de la 1970-01-01 00:00:00 UTC. Fusurile afectează afișarea, nu numărul în sine.