Comment convertir des timestamps Unix en dates (et inversement)

Qu'est-ce qu'un timestamp Unix ?

Un timestamp Unix (aussi appelé temps Unix, temps POSIX ou temps epoch) est le nombre de secondes écoulées depuis 00:00:00 UTC le 1er janvier 1970, sans compter les secondes intercalaires. Ce moment est appelé l'époque Unix.

Par exemple :

• 0 = 1970-01-01 00:00:00 UTC (l'époque)
• 1 000 000 000 = 2001-09-09 01:46:40 UTC (le « billionième »)
• 1 234 567 890 = 2009-02-13 23:31:30 UTC
• 1 700 000 000 = 2023-11-14 22:13:20 UTC
• 2 000 000 000 = 2033-05-18 03:33:20 UTC

Les timestamps Unix sont partout en informatique :

• Bases de données : PostgreSQL, MySQL et SQLite stockent le temps en interne sous forme de timestamps Unix (ou en s'y référant).
• Systèmes de fichiers : ext4, NTFS et APFS stockent les mtimes des fichiers comme timestamps Unix.
• APIs : Les APIs JSON renvoient souvent les timestamps sous forme d'entiers, par ex., `"created_at": 1700000000`.
• Logs : La plupart des systèmes de journalisation émettent des timestamps au format Unix.
• Langages de programmation : PHP, Python, JavaScript, Go, Rust et Java ont tous un support intégré.

La raison pour laquelle les timestamps Unix sont populaires : ce sont de simples entiers, faciles à comparer, à trier, indépendants du fuseau horaire (ils se réfèrent toujours à UTC) et triviaux à stocker. Ils rendent aussi l'arithmétique simple — pour trouver la durée de deux événements, soustrayez leurs timestamps.

Comment lire un timestamp Unix

Le modèle mental : imaginez une horloge qui a commencé à tourner à minuit UTC le 1er janvier 1970, et qui compte les secondes depuis. Le timestamp Unix est la lecture de cette horloge.

``` 1 minute = 60 secondes 1 heure = 3 600 secondes 1 jour = 86 400 secondes (24 × 60 × 60) 1 semaine = 604 800 secondes (7 × 86 400) 1 an ≈ 31 536 000 secondes (365,25 × 86 400, moyenne) 1 décennie ≈ 315 360 000 secondes ```

Quelques ancres mentales :

• 1 000 000 000 = 2001-09-09. Le billionième Unix — la première seconde à 10 chiffres.
• 1 500 000 000 = 2017-07-14. La marque des « 1,5 milliard ».
• 2 000 000 000 = 2033-05-18. La première date à 2 milliards de secondes.
• Le problème de 2038 : Les entiers signés 32 bits débordent à 2 147 483 647, soit 2038-01-19 03:14:07 UTC. Après cela, les timestamps Unix 32 bits reviennent à des valeurs négatives.

Les formules exactes de conversion

Timestamp vers date humaine

``` human_date = époque + timestamp secondes (UTC) local_date = human_date convertie en fuseau horaire local ```

Dans la plupart des langages de programmation :

```python import datetime ts = 1700000000 utc = datetime.datetime.fromtimestamp(ts, tz=datetime.timezone.utc) # 2023-11-14 22:13:20+00:00 local = datetime.datetime.fromtimestamp(ts) # dépend du fuseau horaire de votre système ```

```js const ts = 1700000000; const date = new Date(ts * 1000); // JS utilise les millisecondes // 2023-11-14T22:13:20.000Z ```

Date humaine vers timestamp

``` timestamp = (date - époque) en secondes ```

```python import datetime d = datetime.datetime(2023, 11, 14, 22, 13, 20, tzinfo=datetime.timezone.utc) ts = int(d.timestamp()) # 1700000000 ```

```js const d = new Date("2023-11-14T22:13:20Z"); const ts = Math.floor(d.getTime() / 1000); // 1700000000 ```

Fuseaux horaires courants (relatifs à UTC)

Lorsque vous travaillez avec des timestamps, vous devez souvent afficher dans un fuseau horaire spécifique :

| Fuseau horaire | Abréviation | Décalage | Villes d'exemple | |---------------------------------------|-------------|-----------------|------------------------------| | Temps Universel Coordonné | UTC | 0 | Londres (hiver), Reykjavik | | Heure Normale de l'Est | EST | UTC−5 | New York (hiver) | | Heure Avancée de l'Est | EDT | UTC−4 | New York (été) | | Heure Normale du Pacifique | PST | UTC−8 | Los Angeles (hiver) | | Heure Avancée du Pacifique | PDT | UTC−7 | Los Angeles (été) | | Heure d'Europe Centrale | CET | UTC+1 | Paris (hiver), Berlin | | Heure d'Été d'Europe Centrale | CEST | UTC+2 | Paris (été), Berlin | | Heure Normale du Japon | JST | UTC+9 | Tokyo | | Heure Normale de Chine | CST | UTC+8 | Pékin, Shanghai | | Heure Normale de l'Inde | IST | UTC+5:30 | Mumbai, Delhi | | Heure Normale de l'Est de l'Australie | AEST | UTC+10 | Sydney (hiver) | | Heure d'Été de l'Est de l'Australie | AEDT | UTC+11 | Sydney (été) |

Notez que certains pays (Inde, Chine) observent un seul décalage toute l'année sans heure d'été.

Méthode 1 : Utilisez le convertisseur de temps de UtilBoxx (Recommandé)

La façon la plus rapide, privée et précise de convertir des timestamps Unix dans le navigateur est le Convertisseur de Temps de UtilBoxx. Il prend en charge les secondes et les millisecondes, affiche dans n'importe quel fuseau horaire, et montre la date ISO 8601 correspondante, UTC et heure locale. Tout s'exécute dans votre navigateur : pas de serveur, pas de téléversement, pas de logs.

Comment l'utiliser :

1. Allez sur utilboxx.com/fr/tools/unit/time
2. Saisissez un timestamp Unix (en secondes) ou une chaîne de date
3. La valeur convertie apparaît instantanément
4. Basculez entre fuseaux horaires en un clic
5. Copiez le résultat

Pourquoi nous recommandons cette méthode :

• 100 % gratuit, sans inscription, sans e-mail, sans publicité
• Confidentialité d'abord : rien ne quitte votre navigateur
• Bidirectionnel : timestamp ↔ date dans les deux sens
• Multi-fuseaux horaires : voyez votre timestamp en UTC, votre fuseau local, ou n'importe quel fuseau
• Gère les millisecondes pour les timestamps style JavaScript
• Fonctionne sur tout appareil avec navigateur

Si vous travaillez avec des APIs, des logs ou des bases de données qui stockent le temps comme timestamps Unix, cet outil est rentabilisé la première semaine.

Méthode 2 : Python (module datetime)

Le module `datetime` de Python est l'outil canonique pour la conversion de timestamps. Les deux fonctions clés sont `fromtimestamp()` et `timestamp()`.

```python import datetime from zoneinfo import ZoneInfo

# Convertir timestamp en date (UTC) ts = 1700000000 utc_date = datetime.datetime.fromtimestamp(ts, tz=datetime.timezone.utc) # 2023-11-14 22:13:20+00:00

# Convertir timestamp en date dans un fuseau horaire spécifique ny_tz = ZoneInfo("America/New_York") ny_date = datetime.datetime.fromtimestamp(ts, tz=ny_tz) # 2023-11-14 17:13:20-05:00

# Convertir date en timestamp d = datetime.datetime(2023, 11, 14, 22, 13, 20, tzinfo=datetime.timezone.utc) ts = int(d.timestamp()) # 1700000000

# Maintenant : timestamp actuel now_ts = int(datetime.datetime.now(tz=datetime.timezone.utc).timestamp())

# Formater la date en ISO 8601 print(utc_date.isoformat()) # 2023-11-14T22:13:20+00:00 ```

Python 3.9+ a aussi la forme plus simple `datetime.fromtimestamp(ts, tz=UTC)`, et le module `zoneinfo` (qui remplace l'ancien `pytz`) facilite la gestion des fuseaux horaires.

Méthode 3 : Bash / ligne de commande

La commande `date` sur macOS et Linux peut à la fois analyser et émettre des timestamps Unix.

```bash # Convertir un timestamp Unix en date lisible (macOS / BSD) date -r 1700000000 # Tue Nov 14 22:13:20 UTC 2023

# Convertir un timestamp Unix (Linux / GNU date) date -d @1700000000 # Tue Nov 14 22:13:20 UTC 2023

# Obtenir le timestamp Unix actuel date +%s # 1700000000 (ou ce que c'est maintenant)

# Convertir une chaîne de date en timestamp Unix (GNU) date -d "2023-11-14 22:13:20 UTC" +%s # 1700000000

# Convertir une chaîne de date en timestamp Unix (macOS) date -j -f "%Y-%m-%d %H:%M:%S" "2023-11-14 22:13:20" +%s # 1700000000

# Afficher dans un fuseau horaire spécifique TZ="America/New_York" date -d @1700000000 # Tue Nov 14 17:13:20 EST 2023 ```

La syntaxe diffère entre macOS et Linux. Sur macOS, `-r` lit un timestamp ; sur Linux, `-d @...` lit un timestamp et `-d "..."` analyse une date. Pour scripter, la forme GNU (Linux) est plus conviviale ; la forme macOS est plus laborieuse mais fonctionne.

Méthode 4 : JavaScript (dans le navigateur ou Node.js)

JavaScript utilise les millisecondes pour les timestamps Unix, pas les secondes. Multipliez par 1 000 en passant des secondes aux millisecondes.

```js // Timestamp actuel en millisecondes const now = Date.now(); // p. ex., 1700000000000

// Convertir des secondes en millisecondes et créer un Date const ts = 1700000000; const date = new Date(ts * 1000); // 2023-11-14T22:13:20.000Z

// Afficher dans un fuseau horaire spécifique avec Intl console.log(date.toLocaleString("en-US", { timeZone: "America/New_York" })); // 11/14/2023, 5:13:20 PM

// Afficher en ISO 8601 console.log(date.toISOString()); // 2023-11-14T22:13:20.000Z

// Convertir date en timestamp (secondes) const d = new Date("2023-11-14T22:13:20Z"); const ts2 = Math.floor(d.getTime() / 1000); // 1700000000

// Analyser divers formats new Date("2023-11-14"); // minuit UTC new Date("2023-11-14T22:13:20Z"); // 22:13:20 UTC new Date(1700000000 * 1000); // à partir de millisecondes new Date("Nov 14, 2023 22:13:20");// analyse dépendante de la locale (à éviter !) ```

L'objet `Date` de JavaScript est célèbre pour être capricieux. Pour un travail sérieux, utilisez une bibliothèque comme `date-fns`, `Luxon` ou `Day.js`. Pour des conversions rapides, le `Date` intégré convient.

Questions fréquentes

Pourquoi l'époque Unix est-elle le 1er janvier 1970 ?

C'est la date à laquelle le système d'exploitation Unix a été implémenté pour la première fois. Ken Thompson et Dennis Ritchie l'ont choisi arbitrairement lors de la conception d'Unix aux Bell Labs en 1969-1970. Il n'y a aucune raison astronomique ou mathématique ; c'était simplement le début de la décennie pendant laquelle ils travaillaient. Plusieurs autres systèmes ont choisi des époques différentes : Windows FILETIME utilise le 1er janvier 1601 ; macOS HFS+ utilisait le 1er janvier 1904 ; GPS utilise le 6 janvier 1980.

Qu'est-ce que le problème de 2038 ?

Le problème de 2038 (aussi appelé Y2K38) est le débordement d'entier signé 32 bits qui se produit le 19 janvier 2038 à 03:14:07 UTC. Un entier signé 32 bits peut contenir des valeurs jusqu'à 2 147 483 647. Une seconde plus tard, il déborde vers −2 147 483 648, qui est interprété comme 1901-12-13 20:45:52 UTC. Tout système utilisant encore des timestamps Unix 32 bits (principalement les appareils embarqués, les anciennes bases de données et certains systèmes de fichiers) se cassera à moins d'être mis à jour.

La solution est simple : passer aux entiers 64 bits, ce qui étend la plage des timestamps Unix de 290 milliards d'années. La plupart des systèmes modernes l'ont déjà fait ; le problème concerne principalement les systèmes hérités et embarqués.

Les timestamps Unix sont-ils en secondes ou en millisecondes ?

Cela dépend du langage :

• Secondes : C, Python, Go, Rust, Java (traditionnellement), shell, SQL
• Millisecondes : JavaScript, Java (java.time.Instant), certaines bases de données

JavaScript est le grand cas particulier avec les millisecondes, ce qui entraîne des bugs lorsque du code JavaScript est mélangé avec du code d'autres langages. Précisez toujours l'unité. Le convertisseur de UtilBoxx gère les deux avec un seul commutateur.

Comment les secondes intercalaires affectent-elles les timestamps Unix ?

Strictement parlant, les timestamps Unix ignorent les secondes intercalaires. Ils comptent chaque seconde comme s'il y en avait exactement 86 400 par jour. L'UTC du monde réel a des secondes intercalaires occasionnelles (ajoutées pour maintenir le temps atomique aligné sur la rotation de la Terre), mais le temps Unix ne les inclut pas. Cela signifie que le temps Unix dérive progressivement de l'UTC d'une fraction de seconde tous les quelques années.

En pratique, cela a rarement d'importance pour le code applicatif. NTP (Network Time Protocol) gère la divergence. Si vous avez besoin de TAI strict ou de temps atomique, les timestamps Unix ne sont pas le bon outil.

Qu'est-ce que « ISO 8601 » ?

ISO 8601 est une norme internationale pour les formats de date et d'heure, conçue pour être non ambiguë et lisible par machine. Exemples :

• `2023-11-14` (date seule)
• `2023-11-14T22:13:20` (date et heure, sans fuseau)
• `2023-11-14T22:13:20Z` (UTC, « Z » = « Zulu time »)
• `2023-11-14T22:13:20+05:00` (avec décalage de fuseau)
• `2023-11-14T22:13:20.123Z` (avec millisecondes)
• `20231114T221320Z` (forme compacte, sans séparateurs)

ISO 8601 est le format recommandé pour stocker et échanger des valeurs de date/heure car il se trie lexicographiquement et s'analyse sans ambiguïté. La plupart des APIs l'utilisent.

Comment obtenir le timestamp Unix actuel ?

Dans tous les principaux langages :

```bash # bash date +%s ```

```python import time time.time() # 1700000000.123 (float, avec secondes fractionnaires) int(time.time()) # 1700000000 (secondes entières) ```

```js Date.now() / 1000 // 1700000000.123 Math.floor(Date.now() / 1000) // 1700000000 ```

Conclusion

Les timestamps Unix sont le langage universel du temps en informatique. Ce sont de simples entiers, faciles à comparer, à stocker, et indépendants du fuseau horaire. L'époque est le 1er janvier 1970, et les timestamps comptent les secondes depuis.

Pour des conversions ponctuelles, le Convertisseur de Temps de UtilBoxx est privé, gratuit et fonctionne hors ligne une fois chargé. Pour le travail par lots ou scripté, le `datetime` de Python ou la commande bash `date` gèrent n'importe quel volume de données. Pour le travail interactif, le `Date` de JavaScript est intégré à chaque navigateur.

Le raccourci mental : 1 000 000 000 = 2001 (billionième Unix), 1 500 000 000 = 2017, et 2 000 000 000 = 2033. Avec ces ancres, vous pouvez estimer l'année de n'importe quel timestamp à 10 chiffres dans votre tête. Et rappelez-vous : dans 12 ans, le problème de 2038 arrive, alors auditez vos timestamps 32 bits maintenant.