Convertisseur timestamp Unix

Qu’est-ce qu’un timestamp Unix ?

Un timestamp Unix, aussi appelé temps Unix, heure POSIX ou epoch, est le nombre de secondes écoulées depuis le 1^er janvier 1970 à 00:00:00 UTC. Ce moment s’appelle « l’epoch ». Une seconde plus tard, on était à 1 ; un jour plus tard, à 86 400.

Un même instant a le même timestamp partout sur la Terre. Les fuseaux horaires et le changement d’heure n’interviennent qu’au moment d’afficher une date lisible. C’est pour cela que les serveurs, les bases de données, les journaux et les API l’adorent : un seul entier, sans fuseau, facile à trier et à soustraire.

Secondes ou millisecondes ?

La plupart des systèmes comptent en secondes : un nombre à 10 chiffres aujourd’hui. JavaScript, Java et beaucoup d’API comptent en millisecondes : 13 chiffres. Certaines bases de données et outils de mesure descendent à la microseconde (16 chiffres) ou à la nanoseconde (19 chiffres).

Le convertisseur ci-dessus regarde la longueur du nombre et choisit l’unité pour vous. Si la date tombe en 1970 ou dans un futur lointain, l’unité était sans doute mauvaise : divisez ou multipliez par 1 000.

Le bug de l’an 2038

Beaucoup de systèmes anciens rangent le timestamp dans un entier signé sur 32 bits. La plus grande valeur possible est 2 147 483 647, soit le 19 janvier 2038 à 03:14:07 UTC. Une seconde plus tard, le compteur déborde et passe à −2 147 483 648 : ces systèmes lisent alors le 13 décembre 1901 à 20:45:52.

Les systèmes 64 bits modernes sont tranquilles pour des milliards d’années. Le risque se trouve dans l’embarqué, les vieux formats de fichiers, les bases de données avec des colonnes sur 32 bits et le code qui convertit l’heure en entier 32 bits. Sous Linux, les plateformes 32 bits ont reçu un temps sur 64 bits avec le noyau 5.6 en 2020 et la glibc 2.34 en 2021, mais les logiciels doivent encore être recompilés pour en profiter. Un bon test : enregistrez une date en 2040 et relisez-la.

Le temps Unix et les secondes intercalaires

Le temps Unix fait comme si chaque jour durait exactement 86 400 secondes. L’UTC, lui, a reçu 27 secondes intercalaires depuis 1972, la dernière le 31 décembre 2016. Pendant une seconde intercalaire, le temps Unix répète en général une seconde, ou étire les secondes autour (on parle de « lissage », pratiqué par certains grands hébergeurs). Un timestamp Unix n’est donc pas un compte strict de secondes écoulées : c’est un nombre de jours multiplié par 86 400, plus les secondes du jour en cours.

En pratique, cela compte rarement, et comptera de moins en moins. En novembre 2022, la Conférence générale des poids et mesures a décidé d’élargir d’ici 2035 l’écart permis entre l’UTC et la rotation de la Terre, ce qui revient à abandonner les secondes intercalaires. Le Service international de la rotation terrestre a déjà annoncé qu’il n’y en aurait pas à la fin de décembre 2026.

Fuseaux horaires et changement d’heure

Un timestamp désigne un instant, pas une heure affichée sur une horloge. Au timestamp 1 700 000 000, il était 22:13 à Londres, 23:13 à Paris et 17:13 à New York : trois heures locales, un seul nombre. Pour enregistrer des dates, gardez le timestamp (ou une date ISO 8601 avec « Z ») et ne passez à l’heure locale qu’au moment de l’afficher.

Le changement d’heure le montre bien. La nuit du passage à l’heure d’hiver, l’heure locale de 2h00 à 3h00 se produit deux fois : une heure locale seule est donc ambiguë. Les timestamps, eux, continuent d’avancer seconde après seconde, sans saut. La nuit du passage à l’heure d’été, une heure locale disparaît, mais aucun timestamp ne manque.

Timestamp ou ISO 8601 ?

L’ISO 8601 est le jumeau lisible du timestamp : 2023-11-14T22:13:20Z désigne le même instant que 1 700 000 000. Le timestamp est compact et facile à comparer ; la date ISO se lit facilement dans un journal ou un fichier JSON. Les deux sont sans ambiguïté, à condition que la date ISO porte « Z » ou un décalage comme +01:00.

Obtenir un timestamp Unix dans le code

// Heure Unix actuelle en secondes (Date.now() est en millisecondes)
Math.floor(Date.now() / 1000)

// Timestamp vers date
new Date(1700000000 * 1000).toISOString()   // "2023-11-14T22:13:20.000Z"

// Date vers timestamp
Date.UTC(2026, 0, 1) / 1000                  // 1767225600

import time
from datetime import datetime, timezone

int(time.time())                                       # heure Unix actuelle
datetime.fromtimestamp(1700000000, tz=timezone.utc)    # 2023-11-14 22:13:20+00:00
int(datetime(2026, 1, 1, tzinfo=timezone.utc).timestamp())   # 1767225600

time();                                   // heure Unix actuelle
gmdate('Y-m-d H:i:s', 1700000000);        // "2023-11-14 22:13:20"
strtotime('2026-01-01 00:00:00 UTC');     // 1767225600

-- MySQL (FROM_UNIXTIME utilise le fuseau de la session)
SELECT UNIX_TIMESTAMP();
SELECT FROM_UNIXTIME(1700000000);

-- PostgreSQL
SELECT EXTRACT(EPOCH FROM now())::bigint;
SELECT to_timestamp(1700000000);

-- SQLite
SELECT strftime('%s', 'now');
SELECT datetime(1700000000, 'unixepoch');

date +%s                              # heure Unix actuelle
date -u -d @1700000000                # Linux (date GNU)
date -u -r 1700000000                 # macOS et BSD
date -u -d '2026-01-01 00:00' +%s     # 1767225600 (date GNU)

Les pièges courants

• L’heure locale par accident. Construire une date à partir de « 2026-01-01 00:00 » sans fuseau utilise l’heure locale de l’ordinateur. Ajoutez « Z » ou « UTC », ou utilisez le choix UTC ci-dessus, quand vous parlez d’UTC.
• Des secondes lues comme des millisecondes. Un nombre à 10 chiffres lu en millisecondes tombe en janvier 1970. Un nombre à 13 chiffres lu en secondes tombe dans des dizaines de milliers d’années.
• Les timestamps négatifs. Les dates avant 1970 sont négatives : −86 400 correspond au 31 décembre 1969. La plupart des outils modernes les gèrent, pas tous les anciens.

Pour savoir quelle heure il est ailleurs à un instant donné, utilisez le convertisseur de fuseaux horaires. Pour compter les jours entre deux dates, prenez le calcul de dates, et pour des durées en heures et minutes, le calcul d’heures.