Unix Timestamp in sekondes vs millisekondes: hoekom die datum 1970 wys

Jy het ’n timestamp omgeskakel en beland in Januarie 1970. Dit is selde ’n stukkende horlosie. Die getal is as millisekondes gelees terwyl dit in sekondes gestoor was—of andersom.

Wat is ’n Unix timestamp?

’n Unix timestamp meet tyd sedert die Unix epoch: 1970-01-01 00:00:00 UTC. Dit gebruik gewoonlik heel sekondes. Dieselfde oomblik kan ook as millisekondes gestoor word (sekondes × 1 000). Die getal self merk nie die eenheid nie.

Sekondes vs millisekondes: die 1 000-voudige verskil

Een sekonde is 1 000 millisekondes. Vergelyk 1720000000 met 1720000000000. As die eerste sekondes is en die tweede millisekondes, is dit dieselfde oomblik. Lees die eerste as millisekondes, en die datum spring na 1970.

Hierdie UTC-resultate is uit die getalle hierbo bereken, nie geraai nie.

Waarde	Waarskynlike eenheid	Uitleg (UTC)
1720000000	Sekondes	Moderne datum as sekondes: 2024-07-03 09:46:40 UTC
1720000000000	Millisekondes	Dieselfde oomblik as millisekondes: 2024-07-03 09:46:40 UTC
1720000000 as millisekondes	Verkeerde eenheid	Datum naby 1970: 1970-01-20 21:46:40 UTC

Hoekom wys my timestamp 1970?

As ’n sekondewaarde as millisekondes behandel word, is die getal 1 000 keer te klein. JavaScript tel dan net ’n kort stuk ná die Unix epoch, en die datum bly in 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

Daardie 1970-datum is die epoch plus ongeveer twee weke. Vermenigvuldig sekondes met 1 000 voordat jy dit aan Date gee.

• SEKONDES
• 1720000000
• × 1000
• ↓
• MILLISEKONDES
• 1720000000000

• Sekondewaarde
• ↓
• Per abuis as millisekondes behandel
• ↓
• Datum naby 1970

Is 10 syfers sekondes en 13 millisekondes?

Vir moderne datums is 10 syfers dikwels sekondes en 13 dikwels millisekondes. Dit is ’n vinnige leidraad, nie ’n valideringsreël nie. Die syfertelling verander met die tydsreeks, en sommige API’s stoor mikro- of nanosekondes. Bevestig die eenheid teen dokumentasie of ’n datum wat sin maak.

Hoekom dit so dikwels in JavaScript gebeur

In JavaScript is ’n numeriese Date-waarde millisekondes sedert die epoch. Baie backends, databasisse en Unix-gereedskap stoor steeds sekondes. Om ’n sekondewaarde direk aan Date te gee, is dus ’n algemene fout:

const unixSeconds = 1720000000;

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

wrong is naby 1970 (1970-01-20 21:46:40 UTC). correct is die moderne oomblik (2024-07-03 09:46:40 UTC).

Ander stelsels gebruik ander eenhede

Ander tale, API’s en databasisse kan sekondes of millisekondes gebruik. Sommige stoor mikro- of nanosekondes. Moenie aanneem ’n taal gebruik altyd een eenheid nie—kyk na die dokumentasie. As die getal in JSON is, maak JSON-formateerder en -vergelyking die veld leesbaar; dit sê steeds nie die eenheid nie.

Hoe weet ek watter eenheid my timestamp gebruik?

Gaan hierdie kontroles in volgorde na. Die syfertelling alleen is nie genoeg nie.

1. Kyk na die API- of databasisdokumentasie.
2. Kyk na die benaderde aantal syfers.
3. Vergelyk die waarde met ’n geloofwaardige moderne timestamp.
4. Toets die waarde as sekondes en as millisekondes.
5. Kyk of die resulterende datum sin maak.

As een uitleg in 1970 beland en die ander op ’n datum wat jy herken, is die eenheidsverskil die oorsaak.

Algemene Unix timestamp-foute

• Sekondes as millisekondes gelees. Die datum sak in na 1970, soos in die voorbeeld hierbo.
• Millisekondes as sekondes gelees. Die datum spring ver in die toekoms, of die omskakeling misluk.
• Twee keer met 1 000 vermenigvuldig. ’n Waarde wat al millisekondes was, word enorm en die datum spring eeue vorentoe.
• Twee keer deur 1 000 deel. ’n Sekondewaarde krimp weer, weer naby 1970.
• Die tydsone blameer. ’n Sone kan ure of die kalenderdag skuif. Dit skuif nie ’n moderne timestamp na 1970 nie.
• ’n Geformateerde datumstring as Unix timestamp behandel. ’n Waarde soos 2024-07-03T09:46:40Z is nie ’n epoch-getal nie. Ontleed dit as ’n datum, nie as sekondes nie.

Veroorsaak die tydsone die 1970-probleem?

Gewoonlik nie. ’n Tydsone kan die vertoonde horlosie verander en, naby middernag, die kalenderdatum. Dit maak nie van ’n moderne Unix timestamp 1970 nie. As die resultaat 1970 is, kyk eers na sekondes teenoor millisekondes.

Skakel om en kontroleer ’n Unix timestamp

NEXNARA Datum- en tydomskakelaar kan ’n Unix timestamp in die blaaier omskakel.

Plak Unix-sekondes of millisekondes, gebruik die huidige timestamp, sien UTC en plaaslike tyd, skakel sones om en formateer ’n datum. Outospeur behandel 10 syfers dikwels as sekondes en 13 as millisekondes; jy kan steeds die eenheid kies.

Die omskakeling self gebeur in jou blaaier. Hierdie hulpmiddel stuur nie datums of timestamps na ’n NEXNARA-bediener nie. Advertensies en ander werffunksies gebruik steeds die netwerk; dit is apart van die omskakeling.

Moet jy ’n Unix timestamp nagaan? Maak Datum- en tydomskakelaar oop en vergelyk sekondes met millisekondes.

FAQ

Hoekom wys my Unix timestamp 1970?

Dit is dikwels sekondes wat as millisekondes gelees is. JavaScript hanteer dan ’n veel kleiner getal, so die datum sit kort ná 1970-01-01 00:00:00 UTC. Vermenigvuldig sekondes met 1 000 en skakel weer om.

Is Unix timestamps sekondes of millisekondes?

Gewoonlik sekondes. Baie web-API’s en JavaScript Date gebruik millisekondes. Kyk altyd wat daardie stelsel dokumenteer. Sommige stelsels gebruik mikro- of nanosekondes.

Hoe skakel ek sekondes om na millisekondes?

Vermenigvuldig met 1 000. 1720000000 sekondes is 1720000000000 millisekondes. Andersom deel jy deur 1 000.

Hoekom gebruik JavaScript Date millisekondes?

Die numeriese Date-timestamp in JavaScript word as millisekondes sedert die Unix epoch gedefinieer. Daarom is new Date(unixSeconds) verkeerd wanneer unixSeconds Unix-sekondes is.

Is ’n 10-syfer-timestamp altyd sekondes?

Nee. Vir moderne datums is dit dikwels wel, en 13 syfers is dikwels millisekondes. Die syfertelling is ’n leidraad, nie ’n reël nie. Bevestig met dokumentasie of ’n datum wat sin maak.

Bevat ’n Unix timestamp ’n tydsone?

Nee. ’n Unix timestamp is ’n oomblik getel vanaf 1970-01-01 00:00:00 UTC. Tydsones beïnvloed hoe dit vertoon word, nie die getal self nie.