Qu'est-ce qu'un timestamp Unix ?
Un timestamp Unix (aussi appelé temps epoch ou temps POSIX) correspond au nombre de secondes écoulées depuis le 1er janvier 1970 à 00:00:00 UTC, sans tenir compte des secondes intercalaires. C'est la manière universelle dont les ordinateurs enregistrent un instant précis, indépendamment des fuseaux horaires et des formats de calendrier. Ce calculateur prend un timestamp exprimé en millisecondes (l'unité renvoyée par la plupart des langages de programmation, comme Date.now() en JavaScript) et le convertit en secondes, minutes et jours écoulés depuis l'epoch.
Comment l'utiliser
Saisissez votre temps Unix en millisecondes dans le champ, puis validez. L'outil effectue une division entière par 1000 pour obtenir des secondes Unix complètes — la forme la plus utilisée par les bases de données, les API et la commande date +%s sous Linux. Le tableau de résultats affiche également la valeur d'origine en millisecondes ainsi que les minutes et les jours écoulés, pour des vérifications rapides.
La formule expliquée
La conversion de base s'écrit $$\text{epoch\_s} = \left\lfloor \frac{\text{now\_ms}}{1000} \right\rfloor$$ La division par 1000 transforme les millisecondes en secondes, et la fonction floor (partie entière) supprime la partie fractionnaire afin d'obtenir un timestamp en secondes entières. Pour les minutes, on utilise \( \left\lfloor \frac{\text{now\_ms}}{60000} \right\rfloor \) et pour les jours \( \left\lfloor \frac{\text{now\_ms}}{86\,400\,000} \right\rfloor \), sachant qu'une journée compte 86 400 secondes, soit 86 400 000 ms.
Exemple concret
Supposons que \( \text{now\_ms} = 1\,700\,000\,000\,000 \). Alors $$\text{epoch\_s} = \left\lfloor \frac{1\,700\,000\,000\,000}{1000} \right\rfloor = 1\,700\,000\,000 \text{ secondes}$$ ce qui correspond au 14 novembre 2023. Les minutes depuis l'epoch valent \( \left\lfloor \frac{1\,700\,000\,000\,000}{60000} \right\rfloor = 28\,333\,333 \), et les jours \( \left\lfloor \frac{1\,700\,000\,000\,000}{86\,400\,000} \right\rfloor = 19\,675 \).
Tableau de conversion des unités du temps Unix
Le temps Unix compte le temps écoulé depuis l'époque, le 1 janvier 1970 00:00:00 UTC. Il est généralement stocké en secondes ou en millisecondes. Le tableau ci-dessous donne les unités courantes dans les deux.
| Unité | Secondes | Millisecondes |
|---|---|---|
| 1 milliseconde | 0.001 | 1 |
| 1 seconde | 1 | 1,000 |
| 1 minute | 60 | 60,000 |
| 1 heure | 3,600 | 3,600,000 |
| 1 jour | 86,400 | 86,400,000 |
| 1 semaine | 604,800 | 604,800,000 |
| 1 année commune (365 jours) | 31,536,000 | 31,536,000,000 |
Certaines langues et certains systèmes utilisent une précision plus fine. Les horodatages en microsecondes comptent 1,000,000 unités par seconde, et les horodatages en nanosecondes comptent 1,000,000,000 unités par seconde. Pour convertir des millisecondes en secondes, divisez par 1,000 et arrondissez par défaut : \(\lfloor \text{ms} / 1000 \rfloor\).
Remarque : le temps Unix ignore les secondes intercalaires, donc chaque jour est compté comme exactement 86,400 secondes.
Dates de référence notables des horodatages Unix
| Horodatage (secondes) | Date et heure UTC | Remarque |
|---|---|---|
| 0 | 1 janv. 1970 00:00:00 | L'époque Unix |
| 1,000,000,000 | 9 sept. 2001 01:46:40 | Un milliard de secondes |
| 1,500,000,000 | 14 juil. 2017 02:40:00 | |
| 1,700,000,000 | 14 nov. 2023 22:13:20 | |
| 2,000,000,000 | 18 mai 2033 03:33:20 | Deux milliards de secondes |
| 2,147,483,647 | 19 janv. 2038 03:14:07 | Maximum d'un entier signé de 32 bits |
Les systèmes qui stockent les secondes dans un entier signé de 32 bits débordent une seconde après la dernière ligne. C'est le « problème de l'an 2038 ». Le stockage sur 64 bits l'évite.
Guide de longueur en chiffres
Pour les dates actuelles, le nombre de chiffres d'un horodatage indique son unité :
| Chiffres | Unité |
|---|---|
| 10 | Secondes |
| 13 | Millisecondes |
| 16 | Microsecondes |
| 19 | Nanosecondes |
Exemples d'entrées et de résultats comparés
Chaque résultat est arrondi par défaut : secondes = ⌊ms / 1000⌋, minutes = ⌊secondes / 60⌋, jours = ⌊secondes / 86,400⌋.
| Entrée en millisecondes | Secondes | Minutes | Jours |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 999 | 0 | 0 | 0 |
| 1,000 | 1 | 0 | 0 |
| 59,999 | 59 | 0 | 0 |
| 86,400,000 | 86,400 | 1,440 | 1 |
| 1,700,000,000,000 | 1700000000 | 28,333,333 | 19,675 |
Vérification détaillée de la dernière ligne : \(\lfloor 1{,}700{,}000{,}000{,}000 / 1000 \rfloor = 1{,}700{,}000{,}000\) secondes. Puis \(1{,}700{,}000{,}000 / 60 = 28{,}333{,}333.33\), qui s'arrondit par défaut à 28,333,333 minutes. Enfin \(1{,}700{,}000{,}000 / 86{,}400 = 19{,}675.9\), qui s'arrondit par défaut à 19,675 jours. Le reste de 80,000 secondes correspond à 22 h 13 min 20 s, soit 14 nov. 2023 22:13:20 UTC.
Valeurs négatives : les instants antérieurs à 1970 sont négatifs, et l'arrondi par défaut se fait vers moins l'infini, et non vers zéro. Par exemple, -1 ms donne -1 s, car \(\lfloor -0.001 \rfloor = -1\). La troncature donnerait 0 à la place. La même règle d'arrondi par défaut s'applique aux minutes et aux jours.
FAQ
Pourquoi des secondes et pas des millisecondes partout ? Les anciens systèmes et de nombreuses API (Unix, Postgres, le champ exp des JWT) stockent les secondes, tandis que les navigateurs et Java utilisent les millisecondes. Passer de l'un à l'autre revient simplement à multiplier ou diviser par 1000.
Et les secondes intercalaires ? Le temps Unix ignore les secondes intercalaires : le compte reste une mesure linéaire et régulière, pratique pour les calculs, mais qui ne s'aligne pas parfaitement sur le temps UTC astronomique.
Cela posera-t-il problème en 2038 ? Les systèmes qui stockent ce nombre de secondes dans un entier signé sur 32 bits subiront un dépassement de capacité le 19 janvier 2038. Les systèmes modernes en 64 bits ne sont pas concernés.