Unix Timestamp i sekunder vs millisekunder: hvorfor datoen viser 1970

Du konverterte et timestamp og havnet i januar 1970. Det er sjelden en ødelagt klokke. Tallet ble lest som millisekunder mens det var lagret i sekunder—eller omvendt.

Hva er et Unix timestamp?

Et Unix timestamp måler tid siden Unix epoch: 1970-01-01 00:00:00 UTC. Det bruker vanligvis hele sekunder. Samme øyeblikk kan også lagres som millisekunder (sekunder × 1 000). Tallet selv oppgir ikke enheten.

Sekunder vs millisekunder: forskjellen ×1 000

Ett sekund er 1 000 millisekunder. Sammenlign 1720000000 med 1720000000000. Er det første sekunder og det andre millisekunder, er det samme øyeblikk. Leser du det første som millisekunder, hopper datoen mot 1970.

Disse UTC-resultatene er regnet ut fra tallene over, ikke gjettet.

Verdi	Sannsynlig enhet	Tolkning (UTC)
1720000000	Sekunder	Moderne dato lest som sekunder: 2024-07-03 09:46:40 UTC
1720000000000	Millisekunder	Samme øyeblikk lest som millisekunder: 2024-07-03 09:46:40 UTC
1720000000 som millisekunder	Feil enhet	Dato nær 1970: 1970-01-20 21:46:40 UTC

Hvorfor viser timestampet mitt 1970?

Behandles en sekundverdi som millisekunder, er tallet 1 000 ganger for lite. JavaScript teller da bare et kort stykke etter Unix epoch, så datoen blir 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

Den 1970-datoen er epoch pluss omtrent to uker. Multipliser sekunder med 1 000 før du sender dem til Date.

• SEKUNDER
• 1720000000
• × 1000
• ↓
• MILLISEKUNDER
• 1720000000000

• Sekundverdi
• ↓
• Feilaktig behandlet som millisekunder
• ↓
• Dato nær 1970

Er 10 siffer sekunder og 13 millisekunder?

For moderne datoer er 10 siffer ofte sekunder og 13 ofte millisekunder. Det er et raskt hint, ikke en valideringsregel. Sifferantallet endrer seg med tidsintervallet, og noen API-er lagrer mikro- eller nanosekunder. Bekreft enheten mot dokumentasjon eller en dato som gir mening.

Hvorfor dette skjer så ofte i JavaScript

I JavaScript er en numerisk Date-verdi millisekunder siden epoch. Mange backends, databaser og Unix-verktøy lagrer fortsatt sekunder. Å sende en sekundverdi rett inn i Date er derfor en vanlig feil:

const unixSeconds = 1720000000;

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

wrong ligger nær 1970 (1970-01-20 21:46:40 UTC). correct er det moderne øyeblikket (2024-07-03 09:46:40 UTC).

Andre systemer bruker andre enheter

Andre språk, API-er og databaser kan bruke sekunder eller millisekunder. Noen lagrer mikro- eller nanosekunder. Anta ikke at et språk alltid bruker én enhet—sjekk dokumentasjonen. Står tallet i JSON, kan Formater og sammenlign JSON gjøre feltet lesbart; enheten sier det likevel ikke.

Hvordan vet jeg hvilken enhet timestampet mitt bruker?

Gå gjennom disse sjekkene i rekkefølge. Sifferantallet alene holder ikke.

1. Sjekk API- eller databasedokumentasjonen.
2. Se på omtrentlig antall siffer.
3. Sammenlign verdien med et troverdig moderne timestamp.
4. Test verdien som sekunder og som millisekunder.
5. Sjekk om den resulterende datoen gir mening.

Lander den ene tolkningen i 1970 og den andre på en dato du kjenner igjen, er enhetsfeilen årsaken.

Vanlige Unix timestamp-feil

• Sekunder tolket som millisekunder. Datoen kollapser mot 1970, som i eksempelet over.
• Millisekunder tolket som sekunder. Datoen hopper langt inn i fremtiden, eller konverteringen feiler.
• Gange med 1 000 to ganger. En verdi som allerede var millisekunder blir enorm, og datoen hopper århundrer frem.
• Dele på 1 000 to ganger. En sekundverdi krymper igjen, tilbake nær 1970.
• Skylde på tidssonen. En sone kan flytte timer eller kalenderdagen. Den flytter ikke et moderne timestamp til 1970.
• Behandle en formatert datostreng som Unix timestamp. En verdi som 2024-07-03T09:46:40Z er ikke et epoch-tall. Tolke den som dato, ikke som sekunder.

Forårsaker tidssonen 1970-problemet?

Vanligvis ikke. En tidssone kan endre visningen av klokken og, nær midnatt, kalenderdatoen. Den gjør ikke et moderne Unix timestamp til 1970. Er resultatet 1970, sjekk sekunder mot millisekunder først.

Konverter og sjekk et Unix timestamp

NEXNARA Dato- og tidskonverterer kan konvertere et Unix timestamp i nettleseren.

Lim inn Unix-sekunder eller millisekunder, bruk gjeldende timestamp, se UTC og lokal tid, konverter tidssoner og formater en dato. Autogjenkjenning behandler ofte 10 siffer som sekunder og 13 som millisekunder; du kan likevel velge enhet.

Selve konverteringen skjer i nettleseren din. Verktøyet sender ikke datoer eller timestamps til en NEXNARA-server. Annonser og andre nettstedfunksjoner bruker fortsatt nettet; det er atskilt fra konverteringen.

Trenger du å sjekke et Unix timestamp? Åpne Dato- og tidskonverterer og sammenlign sekunder med millisekunder.

FAQ

Hvorfor viser Unix-timestampet mitt 1970?

Det er ofte sekunder som er lest som millisekunder. JavaScript behandler et mye mindre tall, så datoen havner like etter 1970-01-01 00:00:00 UTC. Multipliser sekunder med 1 000 og konverter på nytt.

Er Unix timestamps sekunder eller millisekunder?

De bruker vanligvis sekunder. Mange web-API-er og JavaScript Date bruker millisekunder. Sjekk alltid hva det systemet dokumenterer. Noen systemer bruker mikro- eller nanosekunder.

Hvordan konverterer jeg sekunder til millisekunder?

Multipliser med 1 000. 1720000000 sekunder er 1720000000000 millisekunder. Den andre veien deler du på 1 000.

Hvorfor bruker JavaScript Date millisekunder?

Det numeriske Date-timestampet i JavaScript er definert som millisekunder siden Unix epoch. Derfor er new Date(unixSeconds) feil når unixSeconds er Unix-sekunder.

Er et 10-sifret timestamp alltid sekunder?

Nei. For moderne datoer er det ofte sekunder, og 13 siffer er ofte millisekunder. Sifferantallet er et hint, ikke en regel. Bekreft med dokumentasjon eller en dato som gir mening.

Inneholder et Unix timestamp en tidssone?

Nei. Et Unix timestamp er et øyeblikk telt fra 1970-01-01 00:00:00 UTC. Tidssoner påvirker visningen, ikke tallet selv.