Convertisseur de timestamp Unix
Convertissez entre timestamps Unix et dates lisibles
Référence des unités de temps
| Unité | Secondes |
|---|---|
| 1 minute | 60 |
| 1 heure | 3 600 |
| 1 jour | 86 400 |
| 1 semaine | 604 800 |
| 30 jours | 2 592 000 |
| 365 jours | 31 536 000 |
| Événement | Timestamp |
|---|---|
| Époque Unix | 0 |
| 1 milliard (sept. 2001) | 1 000 000 000 |
| 1,5 milliard (juil. 2017) | 1 500 000 000 |
| 2 milliards (mai 2033) | 2 000 000 000 |
| Y2038 (max. 32 bits) | 2 147 483 647 |
| 3 milliards (janv. 2065) | 3 000 000 000 |
Obtenir le timestamp Unix actuel en code
JavaScript / TypeScript
Math.floor(Date.now() / 1000) // seconds Date.now() // milliseconds
Python
import time int(time.time()) # seconds
PHP
time() // seconds microtime(true) // with microseconds
Go
time.Now().Unix() // seconds time.Now().UnixMilli() // milliseconds
Ruby
Time.now.to_i # seconds Time.now.to_f # with fractional
Java / Kotlin
System.currentTimeMillis() / 1000 // seconds Instant.now().getEpochSecond() // Java 8+
C# / .NET
DateTimeOffset.UtcNow.ToUnixTimeSeconds() DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
Rust
SystemTime::now() .duration_since(UNIX_EPOCH)?.as_secs()
Swift
Int(Date().timeIntervalSince1970) // seconds
Bash / Shell
date +%s # GNU/Linux date -j +%s # macOS
SQL (PostgreSQL)
SELECT EXTRACT(EPOCH FROM NOW()) SELECT NOW()::timestamp
SQL (MySQL)
SELECT UNIX_TIMESTAMP() SELECT FROM_UNIXTIME(1713024000)
Qu'est-ce que le temps Unix ?
Le temps Unix (aussi appelé temps Epoch, temps POSIX ou timestamp Unix) est un système de suivi du temps sous forme d'un total cumulé de secondes depuis l'époque Unix — le 1er janvier 1970, 00:00:00 UTC. Il a été introduit avec le système d'exploitation Unix aux laboratoires Bell à la fin des années 1960 et est depuis devenu la représentation temporelle la plus utilisée en informatique.
L'avantage principal des timestamps Unix est leur universalité : ils représentent le même instant absolu dans le temps indépendamment du fuseau horaire ou des paramètres régionaux. Un timestamp de 1713024000 signifie toujours le 14 avril 2024, 00:00:00 UTC — que vous le lisiez à New York, Londres ou Tokyo. Cela les rend idéaux pour stocker des timestamps en base de données, synchroniser des systèmes distribués et transmettre des valeurs temporelles sur les réseaux.
Le temps Unix ignore délibérément les secondes intercalaires : chaque jour est traité comme exactement 86 400 secondes. Cela simplifie les calculs au prix d'une dérive occasionnelle par rapport à l'UTC. En pratique, la différence est négligeable — moins de 30 secondes se sont accumulées depuis 1972, date d'introduction des secondes intercalaires.
La limitation la plus significative du temps Unix était le problème de l'année 2038. Les premières implémentations stockaient les timestamps sous forme d'entiers signés sur 32 bits, qui ne peuvent représenter que des valeurs jusqu'à 2 147 483 647 — correspondant au 19 janvier 2038, 03:14:07 UTC. Les systèmes modernes ont largement migré vers des entiers sur 64 bits, qui étendent la plage à environ 292 milliards d'années dans chaque direction.
Questions fréquentes
Qu'est-ce qu'un timestamp Unix ?
Un timestamp Unix est le nombre de secondes écoulées depuis le 1er janvier 1970, 00:00:00 UTC (l'« époque Unix »). Il représente un instant dans le temps sous forme d'un seul entier, indépendamment des fuseaux horaires. Par exemple, le timestamp 0 correspond à minuit le 1er janvier 1970 UTC, et 1000000000 au 9 septembre 2001 à 01:46:40 UTC.
Comment savoir si un timestamp est en secondes ou en millisecondes ?
Comptez les chiffres. Un nombre à 10 chiffres est en secondes (ex. : 1713024000). Un nombre à 13 chiffres est en millisecondes (ex. : 1713024000000). Le Date.now() de JavaScript renvoie des millisecondes, tandis que la plupart des langages côté serveur (Python, PHP, Go, Ruby) renvoient des secondes. Notre convertisseur détecte automatiquement le format.
Qu'est-ce que le problème Y2038 ?
Les systèmes utilisant des entiers signés sur 32 bits pour les timestamps Unix ne peuvent représenter des temps que jusqu'au 19 janvier 2038, 03:14:07 UTC (timestamp 2 147 483 647). Après cela, l'entier déborde. Les systèmes modernes 64 bits évitent totalement ce problème — un timestamp 64 bits peut représenter des dates sur environ 292 milliards d'années.
Le temps Unix gère-t-il les secondes intercalaires ?
Non. Le temps Unix traite chaque jour comme exactement 86 400 secondes, ignorant totalement les secondes intercalaires. Lorsqu'une seconde intercalaire est insérée dans l'UTC, le temps Unix répète effectivement une seconde. La différence accumulée est inférieure à 30 secondes depuis 1972 — négligeable pour la plupart des applications.
Pourquoi le temps Unix commence-t-il le 1er janvier 1970 ?
La date a été choisie lors du développement du système d'exploitation Unix aux laboratoires Bell à la fin des années 1960. C'était un nombre rond (début d'une nouvelle décennie) suffisamment récent pour être utile, et un entier de 32 bits pouvait couvrir assez de temps futur pour être pratique.
Les timestamps Unix peuvent-ils être négatifs ?
Oui. Les timestamps Unix négatifs représentent des dates antérieures au 1er janvier 1970. Par exemple, -86400 représente le 31 décembre 1969. La plupart des langages de programmation et notre convertisseur gèrent correctement les timestamps négatifs.