Qu'est-ce que le temps UNIX ?
Le temps UNIX (aussi appelé timestamp UNIX ou temps POSIX) correspond au nombre de secondes écoulées depuis l'epoch UNIX, soit le 1970-01-01 00:00:00 UTC. C'est une manière universelle et indépendante de tout langage de représenter un instant précis sous la forme d'un seul entier. On l'utilise partout en informatique : journaux d'événements, bases de données, API et programmation. Aucune seconde intercalaire n'est prise en compte : chaque journée est considérée comme durant exactement 86 400 secondes.
Comment utiliser ce convertisseur
Saisissez la date du calendrier (année, mois, jour) ainsi que l'heure (heures, minutes, secondes) telles qu'elles s'affichent sur une horloge locale. Réglez ensuite le champ « Décalage par rapport à UTC » sur le décalage horaire de cette heure locale, exprimé en heures. Par exemple, le Japon est à +9, l'Inde à +5,5 et l'heure normale du Pacifique (États-Unis) à -8. Le décalage par défaut est +9 (heure du Japon). Laissez les champs heures, minutes et secondes vides pour les considérer comme nuls.
La formule expliquée
La date est d'abord convertie en nombre de jours grâce à l'algorithme « days-from-civil » (de Howard Hinnant), qui compte correctement les jours depuis l'epoch pour n'importe quelle date du calendrier grégorien, y compris les années bissextiles et les dates antérieures à 1970. Ce nombre de jours est multiplié par 86 400, puis on y ajoute les heures, les minutes et les secondes pour obtenir le nombre de secondes écoulées depuis le 1970-01-01 00:00:00 en heure locale. Enfin, on soustrait le décalage UTC (en heures × 3600) afin de ramener le résultat en UTC.
$$\begin{gathered} t = 86400 \cdot D + 3600\,\text{Hour} + 60\,\text{Minute} + \text{Second} - 3600\,\text{UTC Offset} \\[1.5em] \text{where}\quad \left\{ \begin{aligned} D &= \text{days from } 1970\text{-}01\text{-}01 \text{ to the chosen date} \\ \text{date} &= \left(\text{Year},\ \text{Month},\ \text{Day}\right) \end{aligned} \right. \end{gathered}$$
Exemple concret
Pour le 2025-06-15 00:00:00 avec un décalage de +9 : daysSinceEpoch = 20254, donc localSeconds = \(20254 \times 86400 = 1\,749\,945\,600\). En soustrayant \(9 \times 3600 = 32\,400\), on obtient un temps UNIX de 1 749 913 200, soit le 2025-06-14 15:00:00 UTC.
Foire aux questions
Pourquoi le timestamp est-il plus petit que prévu pour un décalage positif ? Parce qu'une heure locale en avance sur UTC correspond à un instant UTC plus précoce ; sa valeur UNIX est donc inférieure à celle de la même heure d'horloge lue comme étant en UTC.
Le convertisseur gère-t-il les dates antérieures à 1970 ? Oui : le résultat est simplement négatif. Le 1969-12-31 23:59:59 UTC vaut -1.
Les secondes intercalaires sont-elles incluses ? Non. Le calcul suit la définition standard POSIX, selon laquelle chaque journée dure exactement 86 400 secondes.
Valeurs de référence courantes des horodatages UNIX
Le temps UNIX compte les secondes écoulées depuis le 1970-01-01 00:00:00 UTC (l'époque). Le tableau présente des valeurs connues et la date et l'heure UTC que chacune représente.
| Horodatage UNIX (secondes) | Date et heure (UTC) | Remarque |
|---|---|---|
| -1 | 1969-12-31 23:59:59 | Une seconde avant l'époque |
| 0 | 1970-01-01 00:00:00 | L'époque |
| 86400 | 1970-01-02 00:00:00 | Exactement un jour après l'époque |
| 1000000000 | 2001-09-09 01:46:40 | Un milliard de secondes |
| 1234567890 | 2009-02-13 23:31:30 | Chiffres successifs |
| 1700000000 | 2023-11-14 22:13:20 | 1,7 milliard de secondes |
| 2000000000 | 2033-05-18 03:33:20 | Deux milliards de secondes |
| 2147483647 | 2038-01-19 03:14:07 | Maximum d'un entier signé de 32 bits (231 − 1) |
Les horodatages en secondes comptent actuellement 10 chiffres. La version en millisecondes, utilisée par JavaScript et de nombreuses API, en compte 13. Si un horodatage comporte 13 chiffres, divisez-le par 1000 pour obtenir des secondes.
Conversions d'unités de temps et de décalages horaires
Saisissez le décalage dans le calculateur en heures décimales à l'est de l'UTC (les valeurs négatives sont à l'ouest de l'UTC). Le calculateur soustrait le décalage de l'heure locale pour obtenir l'UTC, donc l'horodatage vaut \(t = t_{\text{locale}} - 3600 \cdot \text{décalage}\). Les décalages ci-dessous sont les décalages standard. L'heure d'été modifie le décalage, généralement d'une heure ; utilisez donc le décalage réellement en vigueur à cette date.
| Fuseau | Décalage par rapport à l'UTC (heures décimales) | Commentaire |
|---|---|---|
| UTC | 0 | Heure de référence |
| JST (heure standard du Japon) | +9 | Pas d'heure d'été |
| IST (heure standard de l'Inde) | +5.5 | +5 h 30 min |
| ACDT (heure d'été du centre de l'Australie) | +10.5 | Heure d'été ; l'heure standard ACST est +9.5 |
| NPT (heure du Népal) | +5.75 | +5 h 45 min |
| CET (heure d'Europe centrale) | +1 | En été, CEST est +2 |
| EST (heure normale de l'Est des États-Unis) | -5 | En été, EDT est -4 |
| PST (heure normale du Pacifique des États-Unis) | -8 | En été, PDT est -7 |
| HST (heure normale de Hawaï) | -10 | Pas d'heure d'été |
| NST (heure normale de Terre-Neuve) | -3.5 | -3 h 30 min ; en été, NDT est -2.5 |
| Conversion d'unité | Valeur |
|---|---|
| Secondes par minute | 60 |
| Secondes par heure | 3600 |
| Secondes par jour | 86400 |
| Secondes en millisecondes | × 1000 (par exemple, new Date(secondes * 1000) en JavaScript) |
Termes clés
- Époque
- Le point de départ d'un décompte du temps. Pour le temps UNIX, il s'agit du 1970-01-01 00:00:00 UTC.
- Horodatage UNIX / temps POSIX
- Le nombre de secondes écoulées depuis l'époque, sans compter les secondes intercalaires. Les dates antérieures à 1970 donnent des valeurs négatives.
- UTC
- Temps universel coordonné, la norme horaire mondiale à laquelle les heures locales sont définies.
- Décalage UTC
- La différence entre une heure locale et l'UTC, par exemple +5:30 ou -8:00. Il est saisi ici en heures décimales (5.5 ou -8).
- Seconde intercalaire
- Un ajustement occasionnel d'une seconde de l'UTC. Le temps UNIX ignore les secondes intercalaires et considère que chaque jour dure exactement 86400 secondes.
- Calendrier grégorien proleptique
- Les règles du calendrier grégorien étendues en arrière aux dates antérieures à son introduction. Les décomptes de jours en temps UNIX utilisent conventionnellement ce calendrier.
- Horodatage en millisecondes
- Un horodatage UNIX multiplié par 1000, comptant généralement 13 chiffres, comme dans JavaScript et Java.
- Problème de l'an 2038
- Les systèmes qui stockent le temps UNIX dans un entier signé de 32 bits débordent après 2147483647 (2038-01-19 03:14:07 UTC). La valeur repasse alors à un nombre négatif, sauf si un type 64 bits est utilisé.