Che cos'è un timestamp Unix? La guida completa

Che cos'è un timestamp Unix?

Un timestamp Unix (chiamato anche POSIX time o Epoch time) è un sistema per tracciare il tempo che conta il numero di secondi trascorsi dall'epoch Unix — 00:00:00 UTC del 1° gennaio 1970 — esclusi i secondi intercalari.

A differenza delle date leggibili che variano in base al fuso orario ("19 luglio 2026, 15:30 EST"), un timestamp Unix è un singolo intero che rappresenta lo stesso istante ovunque sulla Terra. Ad esempio, il timestamp 1785292800 corrisponde a un istante specifico, sia che tu ti trovi a New York, Londra o Tokyo.

I timestamp Unix sono la spina dorsale della gestione del tempo nell'informatica moderna. I sistemi operativi, i linguaggi di programmazione, i database e i file system si affidano tutti a questa semplice rappresentazione intera sotto il cofano.

L'epoch Unix: perché il 1° gennaio 1970?

La scelta del 1° gennaio 1970 come "epoch" (il punto di partenza) non è stata arbitraria. Diverse considerazioni pratiche hanno portato a questa decisione:

• Primo sviluppo di Unix: il sistema operativo Unix fu sviluppato ai Bell Labs tra la fine degli anni '60 e l'inizio degli anni '70. Quando il sistema temporale fu standardizzato nei primi anni '70, il 1° gennaio 1970 era un punto di riferimento recente e pulito.
• Semplicità: il tempo nei primi sistemi Unix era memorizzato come un intero con segno a 32 bit che contava i secondi. L'uso di una data recente massimizzava l'intervallo rappresentabile verso il futuro.
• Precedente: l'epoch fu formalizzato nel primo standard POSIX, rendendolo il riferimento universale per i sistemi derivati da Unix.

I precedenti sistemi Unix-like avevano usato date epoch diverse, ma l'epoch del 1970 ha prevalso ed è stato lo standard per tutti i sistemi conformi a POSIX da allora.

Come funziona il valore del timestamp

L'idea centrale è semplice:

• Un timestamp di 0 significa esattamente 1° gennaio 1970, 00:00:00 UTC
• Un timestamp di 86400 (60 × 60 × 24) significa 2 gennaio 1970, 00:00:00 UTC
• Un timestamp di -3600 significa 31 dicembre 1969, 23:00:00 UTC (i timestamp negativi rappresentano date precedenti all'epoch)

La formula è semplice:

timestamp = seconds since 1970-01-01 00:00:00 UTC

Timestamp in millisecondi

Molti sistemi moderni, in particolare JavaScript e le API web, utilizzano i millisecondi invece dei secondi. Un timestamp in millisecondi è semplicemente il valore in secondi moltiplicato per 1000:

• Date.now() di JavaScript restituisce millisecondi
• time.time() di Python restituisce secondi come float con millisecondi frazionari

Verifica sempre quale risoluzione usa un sistema prima di convertire, poiché mescolarle può produrre date sbagliate di decenni.

Il problema dell'anno 2038

Il problema dell'anno 2038 (chiamato anche "Unix Millennium Bug" o "Y2K38") è un problema di rappresentazione del tempo che interesserà i sistemi che memorizzano i timestamp come interi con segno a 32 bit.

Un intero con segno a 32 bit può contenere valori da circa -2,1 miliardi a +2,1 miliardi. Il timestamp Unix massimo rappresentabile è 2147483647, che corrisponde a:

• 19 gennaio 2038, 03:14:07 UTC

Un secondo dopo, il valore andrebbe in overflow diventando -2147483648, che rappresenta il 13 dicembre 1901 — facendo interpretare ai sistemi il tempo corrente come una data dell'inizio del XX secolo.

Quali sistemi sono interessati?

• Dispositivi embedded e hardware IoT con processori a 32 bit
• Vecchi kernel Linux embedded
• Database legacy che usano colonne temporali a interi a 32 bit
• File system e formati binari che memorizzano il tempo come interi a 32 bit

La soluzione

I sistemi moderni sono in gran parte passati agli interi a 64 bit per la memorizzazione del tempo. Un intero con segno a 64 bit può rappresentare tempi fino a circa 292 miliardi di anni nel futuro — di fatto infinito per qualsiasi scopo pratico.

• La maggior parte delle moderne distribuzioni Linux su hardware a 64 bit è già al sicuro
• Il kernel Linux usa un time_t a 64 bit sui sistemi a 64 bit da anni
• Il kernel 5.6+ ha introdotto il supporto di time_t a 64 bit per le architetture a 32 bit
• Linguaggi di programmazione come Python, Go e Java usano interi a 64 bit internamente

Se mantieni sistemi embedded o software legacy, controllare la dimensione del tuo time_t è un esercizio utile oggi.

UTC e la relazione con i timestamp Unix

I timestamp Unix sono intrinsecamente indipendenti dal fuso orario — si riferiscono sempre a UTC.

Che cos'è UTC?

Il Tempo Universale Coordinato (UTC) è lo standard temporale primario in base al quale il mondo regola orologi e tempo. Ha sostituito il Greenwich Mean Time (GMT) come standard internazionale ed è mantenuto da orologi atomici.

Perché UTC conta per i timestamp Unix

• I timestamp Unix sono definiti in UTC, quindi un timestamp rappresenta lo stesso istante a livello globale
• Convertire un timestamp Unix nell'ora locale è puramente una questione del livello di visualizzazione
• Nessuna informazione sul fuso orario è memorizzata nel timestamp stesso, il che mantiene il sistema semplice e portabile

Questo design significa che puoi condividere un timestamp Unix con chiunque nel mondo e entrambe le parti possono convertirlo nel proprio orario locale senza ambiguità.

Secondi intercalari: la rara eccezione

I timestamp Unix contano teoricamente i secondi dall'epoch, ma ignorano i secondi intercalari. Un giorno con un secondo intercalare aggiunto ha ancora esattamente 86400 secondi nel tempo Unix. Ciò significa che durante un secondo intercalare, il timestamp Unix non avanza e il secondo intercalare sparisce di fatto dal conteggio.

Questa semplificazione mantiene il sistema pratico, ma significa che i timestamp Unix divergono leggermente dal tempo atomico. La discrepanza è abbastanza piccola da contare raramente per le applicazioni di tutti i giorni.

Intervalli di timestamp comuni

| Timestamp | Data leggibile | Significato | |-----------|---------------------|--------------| | 0 | 1970-01-01 00:00:00 UTC | L'epoch Unix | | 86400 | 1970-01-02 00:00:00 UTC | Un giorno dopo l'epoch | | 946684800 | 2000-01-01 00:00:00 UTC | L'anno 2000 | | 1234567890 | 2009-02-13 23:31:30 UTC | Uno schema memorabile | | 1785292800 | 2026-07-19 00:00:00 UTC | L'epoch odierno | | 2147483647 | 2038-01-19 03:14:07 UTC | Massimo a 32 bit |

Riepilogo

Un timestamp Unix è un modo elegante e portabile di rappresentare il tempo come un singolo intero. Il suo design — contare i secondi dal 1° gennaio 1970 UTC — lo rende lo standard temporale universale tra sistemi operativi, database e linguaggi di programmazione. Mentre il problema del 2038 incombe sui sistemi legacy, la transizione in corso al tempo a 64 bit garantisce che il timestamp Unix rimarrà il fondamento della misurazione del tempo informatica per le generazioni a venire.

Pronto a lavorare con i timestamp Unix? Usa il nostro Convertitore di timestamp Unix per convertire all'istante tra timestamp e date leggibili.