Convertissez un timestamp Unix (secondes depuis le 1er janvier 1970) en date lisible et réciproquement. Timestamps en secondes, millisecondes et microsecondes.
3 exemples concrets de conversion de timestamp Unix
Exemple 1 — Convertir un timestamp Unix en date lisible
Le timestamp 1743000000. Étape 1 : divisez par 86 400 (secondes/jour) = 20 174,7 jours depuis le 1er janvier 1970. Étape 2 : 20 174 jours = environ 55,2 ans après l'epoch. Résultat : le 26 mars 2026 à environ 10h00 UTC. En JavaScript : new Date(1743000000 * 1000).toISOString() → "2026-03-26T10:00:00.000Z".
Exemple 2 — Calculer la différence entre deux timestamps
Timestamp A (début d'un événement) : 1742900000. Timestamp B (fin) : 1743000000. Différence : 1 743 000 000 − 1 742 900 000 = 100 000 secondes. Conversion : 100 000 ÷ 3 600 = 27,78 heures soit 27 heures et 46 minutes. Ce calcul est direct et précis, sans se soucier des fuseaux horaires.
Exemple 3 — Générer le timestamp Unix d'une date future
Calculer le timestamp Unix du 1er janvier 2027 00:00:00 UTC. Méthode : depuis l'epoch (1er jan 1970), compter les secondes. En Python : import datetime; datetime.datetime(2027,1,1,tzinfo=datetime.timezone.utc).timestamp() → 1 798 761 600. Ce nombre est indépendant du fuseau horaire dès lors qu'on travaille en UTC.
Tableau de conversions timestamp Unix de référence
| Date (UTC) |
Timestamp Unix |
Remarque |
| 01/01/1970 00:00:00 | 0 | Epoch Unix (origine) |
| 01/01/2000 00:00:00 | 946 684 800 | An 2000 |
| 01/01/2023 00:00:00 | 1 672 531 200 | Référence récente |
| 01/01/2026 00:00:00 | 1 735 689 600 | Début d'année 2026 |
| 01/01/2038 03:14:07 | 2 147 483 647 | Limite 32 bits signés (problème Y2K38) |
| 01/01/2100 00:00:00 | 4 102 444 800 | Lointain, 64 bits requis |
Note : 1 jour = 86 400 secondes. 1 an ≈ 31 557 600 secondes (365,25 jours). Toutes les valeurs sont en UTC.
3 erreurs fréquentes avec les timestamps Unix
- Oublier de multiplier par 1000 en JavaScript : JavaScript utilise les millisecondes depuis l'epoch, pas les secondes.
new Date(1743000000) donne une date en 1970 — il faut new Date(1743000000 * 1000) pour obtenir 2026. Cette erreur est extrêmement fréquente chez les développeurs débutants et génère des bugs silencieux difficiles à détecter.
- Ignorer les fuseaux horaires lors de la conversion : Un timestamp Unix est toujours en UTC. Lorsque vous l'affichez à l'utilisateur, vous devez le convertir en heure locale. "2026-03-26T10:00:00Z" est 11h00 en heure de Paris (UTC+1) et 12h00 en heure d'été (UTC+2). Ne jamais afficher un timestamp UTC comme s'il était en heure locale sans conversion explicite.
- Stocker un timestamp en entier 32 bits signé : Le problème Y2K38 : les systèmes 32 bits signés débordent le 19 janvier 2038 à 03:14:07 UTC (valeur 2 147 483 647). Les systèmes utilisant des entiers 32 bits pour les timestamps (comme certains anciens systèmes Unix et des bases de données MySQL avec TIMESTAMP avant 2038) devront migrer vers des entiers 64 bits avant cette date.
FAQ — Timestamp Unix et temps POSIX
Qu'est-ce qu'un timestamp Unix ?
Un timestamp Unix (ou temps POSIX) est le nombre de secondes écoulées depuis le 1er janvier 1970 à 00:00:00 UTC, sans compter les secondes intercalaires (leap seconds). C'est la manière standard de représenter un point précis dans le temps en informatique, indépendamment du fuseau horaire ou du format de date local. Il est universellement supporté par tous les langages de programmation et systèmes d'exploitation modernes.
Pourquoi 1970 est-il choisi comme date de référence (epoch) ?
Le 1er janvier 1970 a été choisi lors du développement du système d'exploitation Unix dans les laboratoires Bell d'AT&T à la fin des années 1960. C'était une date ronde suffisamment récente pour être pratique et suffisamment éloignée du passé pour couvrir la plupart des cas d'usage de l'époque. Il n'y a pas de raison mathématique particulière — c'est un choix arbitraire devenu un standard mondial par adoption universelle.
Comment obtenir le timestamp Unix actuel dans différents langages ?
JavaScript : Math.floor(Date.now() / 1000). Python : import time; int(time.time()). PHP : time(). Java : System.currentTimeMillis() / 1000. Bash/Shell : date +%s. SQL (MySQL) : UNIX_TIMESTAMP(). SQL (PostgreSQL) : EXTRACT(EPOCH FROM NOW()). En ligne de commande Unix : date +%s.
Qu'est-ce que le problème Y2K38 ?
Le problème Y2K38 est l'équivalent du bug de l'an 2000, mais pour 2038. Les systèmes stockant les timestamps dans un entier signé de 32 bits atteindront leur valeur maximale (2 147 483 647) le 19 janvier 2038 à 03:14:07 UTC. Au-delà, le compteur déborde vers un nombre négatif, revenant à 1901. Les systèmes 64 bits ne sont pas affectés — ils pourront représenter des dates jusqu'en l'an 292 277 026 596.
Comment les secondes intercalaires affectent-elles les timestamps Unix ?
Les timestamps Unix ignorent les secondes intercalaires (leap seconds). Les secondes intercalaires sont ajoutées occasionnellement pour synchroniser le temps atomique avec la rotation terrestre. Il y en a eu 27 depuis 1972. Cela signifie qu'un timestamp Unix ne représente pas le temps physique exact — il peut y avoir un écart de ±27 secondes. Pour les applications financières critiques (trading haute fréquence), on utilise des protocoles spéciaux (PTP, TAI) plutôt que le temps Unix.
Quelle est la différence entre timestamp Unix, ISO 8601 et RFC 3339 ?
Le timestamp Unix est un entier (secondes depuis l'epoch). ISO 8601 est un format texte international : "2026-03-26T10:00:00Z" (le Z signifie UTC). RFC 3339 est une variante de l'ISO 8601 utilisée dans les APIs et protocoles Internet : "2026-03-26T10:00:00+00:00". Pour les APIs REST, le format ISO 8601/RFC 3339 est recommandé pour la lisibilité. Pour le stockage en base de données et les calculs, le timestamp Unix entier est plus efficace.
Comment convertir un timestamp Unix en date locale avec Python ?
En Python, utilisez le module datetime avec pytz ou zoneinfo : from datetime import datetime, timezone; from zoneinfo import ZoneInfo; dt = datetime.fromtimestamp(1743000000, tz=ZoneInfo('Europe/Paris')). Pour afficher : dt.strftime('%d/%m/%Y %H:%M:%S %Z') donne "26/03/2026 12:00:00 CET" (ou CEST selon l'heure d'été). Évitez datetime.fromtimestamp() sans fuseau horaire — il utilise le fuseau du système, qui peut varier.
Peut-on utiliser des timestamps négatifs ?
Oui, les timestamps négatifs représentent des dates antérieures au 1er janvier 1970. Par exemple, −1 correspond au 31 décembre 1969 à 23:59:59 UTC. En Python et JavaScript, les timestamps négatifs sont supportés. Cela permet de représenter des dates historiques, bien que les langages et bases de données varient dans leur support des dates très anciennes (avant 1901 ou 1970 selon les systèmes).
