Unix Timestamp în dată: secunde, milisecunde și UTC explicate

Acesta e un ghid de conversie: timestamp în dată, dată în timestamp, UTC versus local, și ISO 8601. Dacă o valoare devine pe neașteptate o dată din 1970, de obicei e o nepotrivire secunde/milisecunde—vezi Unix Timestamp în secunde vs milisecunde: de ce data arată 1970.

Ce e un Unix Timestamp?

Unix timestamp, Unix time și epoch time înseamnă de obicei timpul scurs de la 1970-01-01 00:00:00 UTC. Numărul nu e un șir de dată formatat cu etichetă de fus. Același instant se poate afișa cu ore diferite în UTC, New York, Tokyo sau Seul. Unix timestamp-urile nu sunt întotdeauna secunde—milisecundele sunt frecvente în practică.

Ce e Unix Epoch?

Unix epoch e 1970-01-01 00:00:00 UTC. Timestamp 0 e acel instant. Un timestamp pozitiv e după epoch. Unele sisteme permit un timestamp negativ pentru un timp înainte de epoch, dar suportul de limbă și de interval de date variază.

Timestamp-ul meu e în secunde sau milisecunde?

1720000000 sunt secunde; 1720000000000 sunt milisecunde; e același instant. Un indiciu practic: circa 10 cifre înseamnă adesea secunde, circa 13 adesea milisecunde. Numărul de cifre e doar o euristică. Date din trecut sau viitor, alte unități sau un epoch personalizat pot arăta altfel. Convertor dată și oră poate converti cu secunde, milisecunde sau auto (≤10 cifre ca secunde, ≥13 ca milisecunde)—alege unitatea când o știi.

De ce unitatea greșită dă data greșită?

JavaScript Date așteaptă milisecunde. Dacă treci 1720000000 ca și cum ar fi milisecunde, obții 1970-01-20 21:46:40 UTC. Tratarea milisecundelor ca secunde, sau invers, aterizează pe o dată cu totul alta. Pentru calea de depanare 1970, vezi Unix Timestamp în secunde vs milisecunde: de ce data arată 1970.

new Date(1720000000);
// 1970-01-20T21:46:40.000Z

Cum convertești un Unix timestamp în secunde

Înmulțește secundele cu 1000 ca să obții milisecunde. JavaScript Date e bazat pe milisecunde, deci folosește new Date(timestamp * 1000).

const timestamp = 1720000000;
const date = new Date(timestamp * 1000);
date.toISOString();
// 2024-07-03T09:46:40.000Z

Cum convertești un timestamp în milisecunde

Treci milisecundele direct la Date. Nu înmulți din nou un timestamp de milisecunde cu 1000.

const timestamp = 1720000000000;
const date = new Date(timestamp);
date.toISOString();
// 2024-07-03T09:46:40.000Z

De ce același timestamp arată o oră diferită?

Un Unix timestamp e un singur instant. Afișarea în UTC, ora locală sau o zonă IANA aleasă schimbă ceasul. Pentru 1720000000000, UTC e 2024-07-03 09:46:40. America/New_York în acea zi e 2024-07-03 05:46:40 (EDT). Asia/Seoul e 2024-07-03 18:46:40 (UTC+9). Valorile New York și Seul vin din Intl, nu dintr-un slogan de decalaj fix.

Un Unix timestamp conține un fus orar?

Nu. Nu stochează America/New_York sau Asia/Seoul. Timestamp-ul identifică un instant. Un fus se aplică când formatezi acel instant ca dată și oră lizibile. Epoch e definit relativ la UTC; numărul însuși nu e «un câmp de fus UTC».

Unix Timestamp versus ISO 8601

1720000000 și 2024-07-03T09:46:40Z pot reprezenta același instant. Unix e o valoare numerică de timp scurs. ISO 8601 e un șir lizibil de dată-oră și poate sfârși cu Z (UTC) sau un decalaj numeric. Z înseamnă UTC; uneori e numit Zulu. Nu sunt același format.

Cum obții Unix timestamp-ul curent?

În JavaScript, Date.now() sunt milisecunde. Math.floor(Date.now() / 1000) sunt secunde. Nu hardcoda «acum» într-un articol; se mută.

Date.now();
Math.floor(Date.now() / 1000);

Poți converti o dată înapoi într-un Unix timestamp?

Da. Dintr-un șir UTC ISO explicit, getTime() întoarce milisecunde; împarte la 1000 și rotunjește în jos pentru secunde.

const date = new Date("2024-07-03T09:46:40Z");
date.getTime();
// 1720000000000
Math.floor(date.getTime() / 1000);
// 1720000000

Atenție la formatele de dată ambigue

03/07/2024 poate însemna 7 martie sau 3 iulie, în funcție de locale. Preferă o dată și oră în stil ISO cu fus sau decalaj. Convertor dată și oră respinge date numerice ambigue precum 01/02/2026 și cere un selector de dată sau o valoare în stil ISO.

Dar ora de vară?

Un Unix timestamp nu stochează un steag DST. Afișajul local aplică regulile zonei. America/New_York folosește decalaje diferite iarna și vara, deci «New York e UTC-5» nu e întotdeauna adevărat.

Unix timestamp-urile includ secundele bisecte?

Timpul POSIX/Unix tipic nu numără secundele bisecte ca SI extra pe o scară continuă. Platformele pot diferi. La conversia de zi cu zi poți ignora detaliul.

Greșeli obișnuite la conversia Unix timestamp

Aceste confuzii produc data greșită sau ceasul greșit:

Secunde tratate ca milisecunde
O valoare modernă de secunde aterizează atunci lângă 1970 în JavaScript Date.

Milisecunde tratate ca secunde
Data sare departe în viitor.

Tratarea a 10 sau 13 cifre ca lege
Numărul de cifre e un indiciu, nu o garanție.

Confundarea UTC cu ora locală
Instantul e același; ceasul afișat poate diferi.

Presupunerea că fusul e în număr
Numele IANA se aplică la afișare, nu sunt stocate în timestamp.

Date ambigue, sloganuri DST sau un ×1000 în plus
Folosește intrare în stil ISO. Nu înmulți din nou un timestamp de milisecunde.

Exemple UTC verificate

Aceste ore UTC au fost calculate, nu ghicite:

Intrare	Unitate	UTC
0	secunde	1970-01-01 00:00:00
1720000000	secunde	2024-07-03 09:46:40
1720000000000	milisecunde	2024-07-03 09:46:40
1720000000	milisecunde	1970-01-20 21:46:40

Un ghid simplu de decizie pentru conversie

Dacă sursa numește unitatea, folosește-o. Dacă nu, numărul de cifre e un indiciu—apoi verifică dacă data arată plauzibil. Convertește secundele în milisecunde când API-ul cere ms. Alege UTC, local sau o zonă IANA pentru afișare. ISO 8601 e util pentru stocare și schimb.

• Ai un Unix timestamp
• ↓
• Unitate specificată? Folosește-o; altfel verifică magnitudinea
• Secunde? ×1000 dacă API-ul are nevoie de milisecunde
• Milisecunde? Folosește direct într-un API bazat pe ms
• Afișează ca UTC, local sau o zonă IANA
• ↓
• Ai nevoie de un șir? ISO 8601 poate potrivi

Convertește Unix timestamp-uri în browser

NEXNARA Convertor dată și oră convertește secunde și milisecunde Unix, arată UTC, ora locală și ISO 8601, și convertește între fusuri IANA.

Modul Unix suportă secunde, milisecunde, unitate auto, ora curentă și dată-în-timestamp. Modul de fus caută nume IANA, folosește zona browserului și aplică decalaje Intl conștiente de DST. Modul de format are ieșire lizibilă pe locale, afișaj 12/24 de ore și o protecție împotriva datelor ambigue. Diferența de date e un mod separat.

Conversia folosește API-urile Date și Intl ale browserului. Valorile din afara a ceea ce Date poate reprezenta sunt respinse. Unitatea auto nu ghicește valorile cu 11–12 cifre; alege secunde sau milisecunde.

Însăși conversia de dată și timestamp se întâmplă în browserul vostru. Intrările nu sunt trimise la un server NEXNARA pentru conversie. Reclamele și alte funcții ale site-ului tot folosesc rețeaua.

Lipește un timestamp în Convertor dată și oră și compară UTC, ora locală și ISO 8601 înainte să alegi unitatea.

FAQ

Cum convertesc un Unix timestamp într-o dată?

Cunoaște unitatea. Pentru secunde în JavaScript, folosește new Date(n * 1000). Pentru milisecunde, new Date(n). Apoi formatează ca UTC, local sau o zonă.

Unix timestamp e în secunde sau milisecunde?

Oricare. Circa 10 cifre înseamnă adesea secunde și circa 13 milisecunde, dar e o euristică, nu o regulă.

De ce timestamp-ul meu arată 1970?

De obicei o valoare de secunde a fost citită ca milisecunde. Vezi Unix Timestamp în secunde vs milisecunde: de ce data arată 1970.

Unix timestamp e întotdeauna UTC?

Epoch e definit relativ la UTC, iar numărul identifică un instant. Fusul de afișare e separat. Nu e un «câmp de fus UTC» stocat.

Un Unix timestamp conține un fus orar?

Nu. Nu poartă un identificator IANA. Fusul se aplică când formatezi instantul.

Cum convertesc o dată în Unix timestamp?

Dintr-un șir UTC ISO, date.getTime() sunt milisecunde; Math.floor(date.getTime() / 1000) sunt secunde.