Unix Timestamp in secondi vs millisecondi: perché la data mostra il 1970

Hai convertito un timestamp e sei finito nel gennaio 1970. Quasi mai è un orologio rotto. Il numero è stato letto in millisecondi quando era in secondi—o il contrario.

Che cos’è un Unix timestamp?

Un Unix timestamp misura il tempo dall’epoch Unix: 1970-01-01 00:00:00 UTC. Di solito usa secondi interi. Lo stesso istante può essere salvato in millisecondi (secondi × 1.000). Il numero non indica l’unità.

Secondi vs millisecondi: la differenza ×1.000

Un secondo sono 1.000 millisecondi. Confronta 1720000000 con 1720000000000. Se il primo è in secondi e il secondo in millisecondi, è lo stesso istante. Leggi il primo come millisecondi e la data salta verso il 1970.

Questi risultati UTC sono calcolati dai numeri sopra, non stimati.

Valore	Unità probabile	Interpretazione (UTC)
1720000000	Secondi	Data moderna letta come secondi: 2024-07-03 09:46:40 UTC
1720000000000	Millisecondi	Lo stesso istante letto come millisecondi: 2024-07-03 09:46:40 UTC
1720000000 come millisecondi	Unità sbagliata	Data vicino al 1970: 1970-01-20 21:46:40 UTC

Perché il mio timestamp mostra il 1970?

Se un valore in secondi viene trattato come millisecondi, il numero è 1.000 volte troppo piccolo. JavaScript conta solo un breve tratto dopo l’epoch Unix, e la data resta nel 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

Quella data del 1970 è l’epoch più un paio di settimane. Moltiplica i secondi per 1.000 prima di passarli a Date.

• SECONDI
• 1720000000
• × 1000
• ↓
• MILLISECONDI
• 1720000000000

• Valore in secondi
• ↓
• Trattato per errore come millisecondi
• ↓
• Data vicino al 1970

10 cifre sono secondi e 13 millisecondi?

Per le date odierne, 10 cifre sono spesso secondi e 13 millisecondi. È un indizio rapido, non una regola di convalida. Il numero di cifre cambia con l’intervallo temporale, e alcune API usano microsecondi o nanosecondi. Conferma l’unità con la documentazione o una data che abbia senso.

Perché succede così spesso in JavaScript

In JavaScript un Date numerico è in millisecondi dall’epoch. Molti backend, database e strumenti Unix memorizzano ancora i secondi. Passare un valore in secondi diretto a Date è un errore frequente:

const unixSeconds = 1720000000;

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

wrong resta vicino al 1970 (1970-01-20 21:46:40 UTC). correct è l’istante moderno (2024-07-03 09:46:40 UTC).

Altri sistemi usano unità diverse

Altri linguaggi, API e database possono usare secondi o millisecondi. Alcuni memorizzano microsecondi o nanosecondi. Non dare per scontato che un linguaggio usi sempre un’unità: leggi la documentazione. Se il numero è in JSON, Formattare e confrontare JSON rende il campo leggibile; non ti dirà comunque l’unità.

Come capisco quale unità usa il mio timestamp?

Segui questi controlli in ordine. Il solo numero di cifre non basta.

1. Controlla la documentazione dell’API o del database.
2. Guarda il numero approssimativo di cifre.
3. Confronta il valore con un timestamp moderno plausibile.
4. Prova il valore come secondi e come millisecondi.
5. Verifica se la data ottenuta ha senso.

Se un’interpretazione cade nel 1970 e l’altra in una data che riconosci, la causa è l’unità.

Errori comuni con Unix timestamp

• Secondi interpretati come millisecondi. La data collassa verso il 1970, come nell’esempio.
• Millisecondi interpretati come secondi. La data salta nel futuro lontano, o la conversione fallisce.
• Moltiplicare due volte per 1.000. Un valore già in millisecondi diventa enorme e la data avanza di secoli.
• Dividere due volte per 1.000. Un valore in secondi si riduce di nuovo, di nuovo vicino al 1970.
• Incolpare il fuso orario. Un fuso può spostare ore o il giorno del calendario. Non porta un timestamp moderno al 1970.
• Trattare una data formattata come Unix timestamp. Un valore come 2024-07-03T09:46:40Z non è un numero epoch. Analizzalo come data, non come secondi.

Il fuso orario causa il problema del 1970?

Di solito no. Un fuso può cambiare l’orologio mostrato e, vicino a mezzanotte, la data del calendario. Non trasforma un Unix timestamp moderno nel 1970. Se il risultato è il 1970, controlla prima secondi contro millisecondi.

Convertire e controllare un Unix timestamp

NEXNARA Convertitore data e ora può convertire un Unix timestamp nel browser.

Incolla secondi o millisecondi Unix, usa il timestamp attuale, vedi UTC e l’ora locale, converti i fusi e formatta una data. Il rilevamento automatico tratta spesso 10 cifre come secondi e 13 come millisecondi; puoi comunque scegliere l’unità.

La conversione avviene nel browser. Questo strumento non invia date né timestamp a un server NEXNARA. Annunci e altre funzioni del sito usano ancora la rete; è distinto dalla conversione.

Devi controllare un Unix timestamp? Apri Convertitore data e ora e confronta secondi e millisecondi.

FAQ

Perché il mio Unix timestamp mostra il 1970?

Spesso sono secondi letti come millisecondi. JavaScript tratta un numero molto più piccolo, così la data cade poco dopo 1970-01-01 00:00:00 UTC. Moltiplica i secondi per 1.000 e riconverti.

Gli Unix timestamp sono in secondi o in millisecondi?

Di solito usano i secondi. Molte API web e Date in JavaScript usano i millisecondi. Controlla la documentazione. Alcuni sistemi usano microsecondi o nanosecondi.

Come converto i secondi in millisecondi?

Moltiplica per 1.000. 1720000000 secondi sono 1720000000000 millisecondi. Nell’altro senso, dividi per 1.000.

Perché Date in JavaScript usa i millisecondi?

Il timestamp numerico di Date in JavaScript è definito in millisecondi dall’epoch Unix. Per questo new Date(unixSeconds) è sbagliato se unixSeconds è in secondi Unix.

Un timestamp a 10 cifre è sempre in secondi?

No. Per le date odierne spesso sì, e 13 cifre sono spesso millisecondi. Il conteggio delle cifre è un indizio, non una regola. Conferma con la documentazione o una data coerente.

Un Unix timestamp contiene il fuso orario?

No. Un Unix timestamp è un istante contato da 1970-01-01 00:00:00 UTC. I fusi influenzano come viene mostrato, non il numero.