Comprendre les timestamps Unix et l’Epoch Time
Comprenez l’époque Unix, les unités, l’UTC, la précision des entiers, les limites 2038 et 2106 et les secondes intercalaires, avec du code.
Un timestamp situe un événement sur une échelle de temps. Pour échanger une valeur, il faut convenir de l’époque, de l’unité et de la nature de l’horloge. Un compteur depuis le démarrage ne représente pas directement une date UTC. Le Convertisseur Unix Timestamp / Epoch permet d’inspecter un instant et sa représentation locale sans envoyer les données à un serveur.
L’époque Unix : pourquoi le 1er janvier 1970 ?
L’origine est le 1er janvier 1970 à 00:00:00 UTC. C’est une convention historique issue d’Unix, sans origine physique particulière. Changer d’époque change le nombre, pas l’événement. Le temps NTP utilise une origine en 1900 ; GPS et certains composants utilisent d’autres conventions. Une valeur numérique seule ne permet donc pas d’identifier son époque.
Fonctionnement, valeurs positives et négatives
Dans le calcul calendaire POSIX ordinaire, un jour UTC nominal correspond à 86 400 secondes. Le 2 janvier 1970 à minuit UTC vaut donc 86400. Cela ne signifie pas qu’un jour local dure toujours 24 heures. Les valeurs positives suivent l’époque ; −1 désigne la dernière seconde de 1969. Le timestamp lui-même est indépendant du fuseau horaire.
Secondes, millisecondes, microsecondes et nanosecondes
| Unité du timestamp | 1 s | 1700000000 s |
|---|---|---|
| Secondes (s) | 1 | 1700000000 |
| Millisecondes (ms) | 1000 | 1700000000000 |
| Microsecondes (µs) | 1000000 | 1700000000000000 |
| Nanosecondes (ns) | 1000000000 | 1700000000000000000 |
Multipliez les secondes par 1000 pour obtenir des millisecondes, et par un milliard pour des nanosecondes. L’unité change, pas l’exactitude de l’horloge : ajouter six zéros à une mesure en millisecondes ne crée pas une mesure nanoseconde. JavaScript Date reçoit des millisecondes ; de nombreuses interfaces C reçoivent des secondes. Précisez l’unité dans les champs et les contrats d’interface.
UTC, décalages et fuseaux IANA
2023-11-14 22:13:20 UTC et 23:13:20 à Paris désignent le même instant. Le décalage +01:00 décrit une différence ponctuelle ; Europe/Paris apporte les règles civiles et leurs transitions. Une abréviation comme CST est insuffisante, car plusieurs régions l’utilisent.
Heures inexistantes et ambiguës
À Paris, le 31 mars 2024 à 02:30 n’existe pas. Le 27 octobre 2024 à 02:30 apparaît deux fois : 00:30 UTC et 01:30 UTC. Le convertisseur refuse les heures inexistantes et propose de choisir la première ou la seconde occurrence d’une heure répétée. Le numéro du jour dans l’année est calculé à partir des champs du calendrier local, sans diviser une durée locale par 24 heures. Les résultats historiques et futurs dépendent des données IANA du navigateur et des décisions politiques.
Exemple détaillé et valeurs représentatives
1700000000 s multiplié par 1000 donne 1700000000000 ms : les deux correspondent à 2023-11-14T22:13:20Z. L’ajout de 123456789 ns produit 1700000000123456789 ns, soit une fraction .123456789. Date n’en affiche que .123 : les 456789 ns restants sont conservés séparément par le convertisseur.
| Secondes 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 correspond à 1969-12-31T23:59:59.999999999Z. La milliseconde qui contient cet instant vaut −1 ms. Une division entière tronquée vers zéro afficherait à tort l’époque. Il faut arrondir le quotient vers moins l’infini et conserver le reste.
Entiers signés 32 bits : le problème de 2038
Un compteur signé sur 32 bits couvre −2³¹ à 2³¹−1. En secondes Unix, sa dernière valeur positive est 2147483647, le 19 janvier 2038 à 03:14:07 UTC. La seconde suivante ne tient plus. En C, le dépassement signé a un comportement indéfini : ne comptez pas sur un retour automatique en 1901. Élargissez les opérandes avant le calcul et auditez les champs stockés et transmis.
Entiers non signés 32 bits : l’année 2106
La plage 0 à 4294967295 secondes se termine le 7 février 2106 à 06:28:15 UTC et ne représente pas directement les dates avant 1970. Passer au non signé déplace la limite et modifie le sens des valeurs négatives ; ce n’est pas une migration générale vers un format pérenne.
Représentations 64 bits et précision numérique
Un entier signé 64 bits en secondes couvre environ 292 milliards d’années de chaque côté de l’origine. En nanosecondes, cette même largeur ne couvre qu’environ 292 ans, jusqu’à 2262 côté positif. La bibliothèque calendaire peut avoir une plage bien plus petite. Binary64 représente tous les entiers jusqu’à 2⁵³−1 seulement : utilisez BigInt ou une chaîne décimale pour les timestamps nanosecondes actuels. Un flottant 32 bits n’a pas la précision d’un entier 32 bits.
Secondes intercalaires et limites POSIX
Le temps POSIX ne compte pas chaque seconde SI effectivement écoulée depuis 1970 et ne fournit pas de timestamp ordinaire distinct à la seconde UTC :60. Selon leur politique, les systèmes répètent, ajustent ou lissent l’heure lors d’une insertion. Ne convertissez pas Unix vers TAI ou GPS avec un décalage supposé éternel, et n’utilisez pas l’horloge civile pour garantir une durée physique traversant une correction.
JavaScript / TypeScript : conserver l’entier
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());
La date affichée est 2023-11-14T22:13:20.123Z, tandis que l’entier d’origine conserve toute la fraction. Le convertisseur vérifie la valeur nanoseconde complète avant de construire Date et reconstitue les fractions ISO et RFC 3339. RFC 3339 utilise une année sur quatre chiffres : hors de 0000–9999, cette ligne signale son indisponibilité. RFC 2822 affiche des secondes entières et demande une année au moins égale à 1900.
Python : éviter le passage par un flottant
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())
L’UTC explicite évite une dépendance au fuseau de la machine. Cette arithmétique timedelta conserve les microsecondes entières ; timestamp() renvoie un flottant qui peut perdre des fractions fines. datetime ne stocke pas les nanosecondes. Utilisez zoneinfo pour les fuseaux IANA et définissez la politique des heures répétées.
C et systèmes embarqués
#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;
}
Les produits montrés tiennent dans int64_t ; une fonction générale doit vérifier les bornes avant multiplication. Un processeur 64 bits ne garantit pas un time_t 64 bits. Ne sérialisez pas directement time_t : largeur, représentation et ordre des octets dépendent de l’ABI. Définissez époque, unité et signe dans le protocole. Utilisation des timestamps Unix dans les systèmes embarqués, API et bases de données détaille la synchronisation et le stockage.
Erreurs fréquentes
- Donner des secondes à Date ou deviner l’unité uniquement par la longueur du nombre.
- Convertir une longue chaîne en Number avant BigInt : les chiffres perdus ne reviennent pas.
- Ajouter deux fois un décalage horaire à un instant déjà défini.
- Accepter le 31 février parce qu’un constructeur normalise cette date en mars.
- Confondre résolution d’affichage et exactitude de l’horloge.
FAQ technique
Changer de fuseau modifie-t-il le timestamp ?
Non : seule sa représentation calendaire change. Interpréter de nouveaux champs de date locale est une autre opération, qui nécessite un fuseau.
Un timestamp négatif peut-il avoir une fraction ?
Oui : −0.5 s désigne une demi-seconde avant l’époque. Conservez le signe dans les conversions ; seul le quotient destiné à l’affichage calendaire doit être arrondi.
L’horloge actuelle est-elle un service de temps réseau ?
Non. Elle lit l’horloge de votre appareil, dont la qualité dépend du système. Le convertisseur ne contacte aucun serveur NTP.
Outils associés et sources
Utilisez Convertisseur Unix Timestamp / Epoch, consultez Utilisation des timestamps Unix dans les systèmes embarqués, API et bases de données et complétez avec le guide des tolérances de fréquence et le calculateur PPM ↔ Hz.