Comprendere i timestamp Unix e il tempo Epoch
Comprendi epoca Unix, unità, UTC, precisione intera, limiti del 2038 e 2106 e secondi intercalari con esempi di codice.
Un timestamp colloca un evento su una scala temporale. Per scambiare un valore occorre concordare epoca, unità e tipo di orologio. Un contatore dall’avvio non rappresenta una data UTC. Convertitore Unix Timestamp / Epoch consente di verificare valori e fusi senza inviare i calcoli a un server.
Epoca Unix: perché il 1º gennaio 1970?
L’origine è 1970-01-01 00:00:00 UTC, una convenzione storica di Unix senza un significato fisico speciale. Un’epoca diversa cambia il numero, non l’evento. NTP parte dal 1900; GPS e contatori dei produttori hanno altre convenzioni. Una sola cifra numerica non identifica l’epoca.
Conteggio e valori negativi
Nell’aritmetica ordinaria del calendario POSIX, un giorno UTC nominale vale 86400 secondi. Il 2 gennaio 1970 a mezzanotte UTC vale quindi 86400. Ciò non significa che ogni giorno locale duri 24 ore. I valori positivi seguono l’epoca; −1 è l’ultimo secondo del 1969. Il numero Unix è indipendente dal fuso orario.
Secondi, millisecondi, microsecondi e nanosecondi
| Unità del timestamp | 1 s | 1700000000 s |
|---|---|---|
| Secondi (s) | 1 | 1700000000 |
| Millisecondi (ms) | 1000 | 1700000000000 |
| Microsecondi (µs) | 1000000 | 1700000000000000 |
| Nanosecondi (ns) | 1000000000 | 1700000000000000000 |
Moltiplica i secondi per 1000 per ottenere millisecondi o per un miliardo per nanosecondi. Aggiungere zeri non migliora l’accuratezza della sorgente. JavaScript Date riceve millisecondi; molte interfacce C ricevono secondi. Specifica l’unità nel nome del campo e nel contratto dei dati.
UTC, scostamenti e identificatori IANA
2023-11-14 22:13:20 UTC e 23:13:20 a Parigi sono lo stesso istante. +01:00 descrive uno scostamento puntuale; Europe/Paris comprende regole civili e transizioni. Abbreviazioni come CST sono ambigue fra regioni.
Ore inesistenti e ripetute
A Parigi, 2024-03-31 02:30 non esiste. 2024-10-27 02:30 ricorre due volte: 00:30 UTC e 01:30 UTC. Il convertitore rifiuta le ore inesistenti e permette di scegliere la prima o seconda occorrenza. Il giorno dell’anno deriva dai campi del calendario locale, senza dividere una durata locale per 24 ore. I risultati dipendono dai dati IANA del browser; le regole future possono cambiare politicamente e i dati storici hanno limiti.
Calcolo dettagliato e valori rappresentativi
1700000000 s × 1000 = 1700000000000 ms: entrambi indicano 2023-11-14T22:13:20Z. Aggiungendo 123456789 ns si ottengono 1700000000123456789 ns e la frazione .123456789. Date mostra .123; il convertitore conserva separatamente i restanti 456789 ns.
| Secondi Unix | ISO 8601 (UTC) |
|---|---|
| -1 | 1969-12-31T23:59:59Z |
| 0 | 1970-01-01T00:00:00Z |
| 1000000000 | 2001-09-09T01:46:40Z |
| 1700000000 | 2023-11-14T22:13:20Z |
| 2147483647 | 2038-01-19T03:14:07Z |
| 4294967295 | 2106-02-07T06:28:15Z |
−1 ns corrisponde a 1969-12-31T23:59:59.999999999Z. Il millisecondo che contiene l’istante è −1 ms. Troncare la divisione verso zero mostrerebbe erroneamente l’epoca. Arrotonda il quoziente verso meno infinito e conserva il resto.
Il problema del 2038: interi a 32 bit con segno
L’intervallo è da −2³¹ a 2³¹−1. L’ultimo secondo positivo, 2147483647, è 2038-01-19T03:14:07Z. Il successivo non entra nel tipo. In C l’overflow con segno ha comportamento indefinito: non affidarti a un apparente ritorno al 1901. Allarga gli operandi prima del calcolo e verifica file e protocolli.
Contatori senza segno e 2106
L’intervallo 0–4294967295 termina a 2106-02-07T06:28:15Z e non rappresenta direttamente date prima del 1970. Usare unsigned sposta il limite e cambia il significato dei negativi; non sostituisce una migrazione duratura del formato.
Intervalli a 64 bit e precisione
I secondi a 64 bit con segno coprono circa 292 miliardi di anni per direzione; i nanosecondi della stessa larghezza solo circa 292 anni, fino al 2262 nel verso positivo. Le librerie di calendario possono avere limiti inferiori. Binary64 rappresenta tutti gli interi soltanto fino a 2⁵³−1. I nanosecondi attuali richiedono BigInt o stringhe decimali in JavaScript. Un float a 32 bit non ha la precisione di un contatore intero a 32 bit.
Secondi intercalari e limiti POSIX
POSIX non conta ogni secondo SI effettivamente trascorso dal 1970 né assegna un timestamp ordinario distinto al secondo UTC :60. I sistemi possono saltare, ripetere o distribuire la correzione. Non convertire verso TAI o GPS con uno scostamento ritenuto costante per sempre. Sottrarre orari civili non garantisce una durata fisica attraverso una correzione.
JavaScript / TypeScript
const timestampNs = BigInt("1700000000123456789");
const divisor = BigInt(1_000_000);
const q = timestampNs / divisor;
const ms = timestampNs < 0 && timestampNs % divisor !== BigInt(0)
? q - BigInt(1) : q;
if (ms < BigInt("-8640000000000000") || ms > BigInt("8640000000000000")) {
throw new RangeError("Date");
}
const iso = new Date(Number(ms)).toISOString();
console.log(iso);
console.log(timestampNs.toString());
Date mostra 2023-11-14T22:13:20.123Z, mentre l’intero originale conserva la frazione completa. Il convertitore valida l’intero valore prima di costruire Date e ricompone separatamente ISO e RFC 3339. RFC 3339 usa anni di quattro cifre: fuori da 0000–9999 l’uscita risulta indisponibile. RFC 2822 mostra secondi interi e richiede un anno dal 1900.
Python senza passaggio in virgola mobile
from datetime import datetime, timezone, timedelta
epoch = datetime(1970, 1, 1, tzinfo=timezone.utc)
instant = datetime(2023, 11, 14, 22, 13, 20, 123456, tzinfo=timezone.utc)
delta = instant - epoch
timestamp_us = ((delta.days * 86400 + delta.seconds) * 1_000_000
+ delta.microseconds)
restored = epoch + timedelta(microseconds=timestamp_us)
assert restored == instant
print(timestamp_us, restored.isoformat())
UTC esplicito evita la dipendenza dal fuso del computer. timedelta preserva microsecondi interi; timestamp() restituisce un float che può arrotondare frazioni fini. datetime non memorizza nanosecondi. Usa zoneinfo per IANA e stabilisci una regola per le ore ripetute.
C e memorizzazione embedded
#include <stdint.h>
#include <inttypes.h>
#include <stdio.h>
int main(void) {
int64_t seconds = INT64_C(1700000000);
int64_t milliseconds = seconds * INT64_C(1000);
int64_t after_2038 = (int64_t)INT32_MAX + INT64_C(1);
printf("%" PRId64 " %" PRId64 "\n", milliseconds, after_2038);
return 0;
}
Questi prodotti rientrano in int64_t; il codice generico deve verificare i limiti prima di moltiplicare. Una CPU a 64 bit non garantisce time_t a 64 bit. La serializzazione diretta dipende da ABI, larghezza e ordine dei byte. Definisci epoca, unità, segno e larghezza nel protocollo. Vedi Timestamp Unix nei sistemi embedded, nelle API e nei database.
Errori frequenti
- Passare secondi a Date o dedurre l’unità dal numero di cifre.
- Convertire una stringa lunga in Number prima di BigInt, perdendo cifre irrecuperabili.
- Applicare due volte lo scostamento del fuso.
- Accettare il 31 febbraio per normalizzazione automatica.
- Confondere risoluzione visiva e accuratezza dell’orologio.
FAQ tecniche
Cambiare fuso modifica il timestamp?
Cambia soltanto la rappresentazione dell’istante. Interpretare nuovi campi locali richiede invece un fuso.
Un valore negativo può avere una frazione?
Sì. −0.5 s è mezzo secondo prima dell’epoca. Conserva segno e resto durante la conversione.
L’orologio attuale consulta un servizio di rete?
Legge l’orologio del dispositivo senza interrogare NTP. L’accuratezza dipende dalla sincronizzazione del sistema.
Strumenti e fonti
Convertitore Unix Timestamp / Epoch · Timestamp Unix nei sistemi embedded, nelle API e nei database · Tolleranza di frequenza · PPM ↔ Hz.