Timestamp Unix : convertir un epoch et éviter les erreurs de fuseau

Timestamp Unix : convertir un epoch et éviter les erreurs de fuseau

Convertissez un epoch Unix en date lisible et inversement, distinguez secondes et millisecondes, et évitez les pièges de fuseau, de JWT et de changement d’heure.

19.10.2026
20 min de lecture
Partager cet article:
Timestamp UnixEpochFuseau horaireJWTTutoriel

Un epoch compte des secondes et ne porte aucun fuseau horaire

Un nombre comme 1710000000 ou 1710000000000 apparaît dans une ligne de log, une réponse d’API, un JWT ou une colonne de base de données. Il compte le temps écoulé depuis le 1er janvier 1970 à 00:00:00 UTC, en secondes ou en millisecondes. Il ne porte aucun fuseau horaire. Le convertisseur de timestamp Unix transforme un epoch en date et une date en epoch. Les champs vides suivent une horloge en direct. Saisissez un epoch, une date ISO ou une date et une heure locales, et les deux autres champs se mettent à jour. Un tableau donne l’epoch en secondes et en millisecondes, puis l’ISO 8601, la RFC 2822, un datetime SQL, un texte dans votre langue et un temps relatif. Il les montre en UTC ou dans le fuseau de votre navigateur. La conversion se fait dans l’onglet et rien n’est envoyé. Ce guide lit un epoch chiffre par chiffre, puis montre ce qu’un fuseau change et ce qu’il laisse intact. Il traite les erreurs qui coûtent le plus cher : des secondes lues comme des millisecondes, un JWT qui n’expire jamais, une date écrite sans fuseau et un changement d’heure. Il donne aussi les limites de 2038 et des autres epochs, puis les mêmes conversions en JavaScript, en Python, dans un shell et en Java. Les outils voisins sont listés dans le hub des utilitaires développeur.

Une horloge en direct en haut de la page, avec l’epoch actuel en secondes et en millisecondes, un bouton Pause et un bouton Copier ISO (UTC)
Trois champs liés : Epoch Unix, ISO / texte date et Date/heure locale. Modifiez-en un, les deux autres suivent
Une unité détectée seule : jusqu’à 10 chiffres, l’outil lit des secondes, de 11 à 15 chiffres des millisecondes, et un badge indique son choix
Un tableau de formats avec un bouton Copier sur chaque ligne : epoch en secondes, epoch en millisecondes, ISO 8601, RFC 2822, datetime SQL, chaîne locale et temps relatif
Un affichage en UTC ou en Local. Local désigne le fuseau de votre navigateur : l’outil n’a pas de liste de fuseaux
Les epochs négatifs et les fractions de seconde sont acceptés, et l’outil refuse les valeurs de plus de 15 chiffres au lieu de les tronquer
Aucun envoi : le calcul reste dans le navigateur

À quoi sert le convertisseur, et où il s’arrête

Les bons usages

Le convertisseur répond à deux questions : quel instant désigne ce nombre, et quel nombre désigne cet instant ?

Lire un epoch dans une ligne de log, un champ d’API ou une ligne de base de données, et regarder le badge pour savoir si l’outil l’a lu en secondes ou en millisecondes
Écrire une date en epoch pour une requête, un jeu de test ou une fixture, puis copier la ligne voulue
Passer d’UTC à Local pour voir de combien un fuseau déplace le même instant, et sur quel jour il tombe
Contrôler les claims <code>exp</code>, <code>iat</code> et <code>nbf</code> d’un jeton en collant chaque nombre avec l’unité réglée sur Secondes
Coller la ligne ISO 8601 dans un ticket ou une revue de code, pour que le lecteur voie la date avec son décalage
Utiliser Pause sur l’horloge en direct pour garder un epoch fixe pendant la copie
Ce qui relève d’un autre outil

Le convertisseur lit une valeur à la fois. Le reste de la chaîne se contrôle ailleurs.

Décoder un jeton pour lire ses claims : le <a href="/fr/jwt-decode" class="text-primary hover:underline">décodeur JWT</a> affiche <code>exp</code> tel quel, comme nombre brut du payload, et le <a href="/fr/blog/encoder-decoder-jwt-en-ligne" class="text-primary hover:underline">guide JWT</a> explique les claims
Savoir quand une tâche se déclenche : le <a href="/fr/cron-parser" class="text-primary hover:underline">parseur cron</a> calcule les prochaines exécutions, et le <a href="/fr/blog/parser-expression-cron-prochain-run" class="text-primary hover:underline">guide cron</a> aborde les fuseaux et les changements d’heure dans ce cadre
Mettre un log de serveur web en tableau : l’outil <a href="/fr/access-log-to-table" class="text-primary hover:underline">access log en tableau</a> garde la date telle qu’elle est écrite, par exemple <code>09/Mar/2024:16:00:00 +0000</code>, que le convertisseur refuse. Réécrivez-la d’abord en <code>2024-03-09T16:00:00+00:00</code>
Choisir un fuseau nommé comme Tokyo : le convertisseur propose UTC et le fuseau de votre navigateur seulement. Utilisez <code>Intl.DateTimeFormat</code> ou la bibliothèque de fuseaux de votre langage (voir le code plus bas)
Lire des microsecondes, des nanosecondes ou un FILETIME Windows : ces valeurs ont 16 chiffres ou plus et sont refusées. Divisez vous-même par 1000 ou par 10 000 000, et retranchez le décalage d’epoch quand il y en a un
Convertir un fichier entier : l’outil lit une valeur à la fois
Ajouter un mois ou une année à une date : prenez une bibliothèque de dates, car sur une horloge locale un jour ne fait pas toujours 86 400 secondes

Lire une valeur sans se tromper

Distinguer secondes et millisecondes grâce aux chiffres

En mode Auto, l’outil compte les chiffres de la partie entière, signe exclu. Vous pouvez coller les exemples suivants dans le champ Epoch Unix.

<code>1710000000</code> a 10 chiffres et se lit en secondes : samedi 9 mars 2024 à 16:00:00 UTC. Le badge affiche « Déduit : secondes »
<code>1710000000000</code> a 13 chiffres et se lit en millisecondes. Il donne le même instant, et le badge affiche « Déduit : millisecondes »
Du 9 septembre 2001 (<code>1000000000</code>) au 20 novembre 2286 (<code>9999999999</code>), un epoch en secondes a 10 chiffres. Sur la même période, un epoch en millisecondes en a 13
<code>10000000000</code> a 11 chiffres et se lit en millisecondes : 26 avril 1970 à 17:46:40 UTC. Une valeur de cette taille en secondes serait l’année 2286
Une date de janvier 1970 signifie presque toujours que des secondes ont été lues comme des millisecondes. <code>1710000000</code> lu en millisecondes donne le 20 janvier 1970 à 19:00:00 UTC. Réglez l’unité sur Millisecondes pour le voir
Une date de l’année <code>56157</code> signifie l’inverse. <code>1710000000000</code> lu en secondes donne <code>+056157-09-28T16:00:00.000Z</code>. Réglez l’unité sur Secondes pour le voir
À partir de 16 chiffres, l’outil répond « Cette valeur semble plus précise que des millisecondes » et n’affiche aucune date
Fractions, signes et ce que le champ refuse

Le champ Epoch Unix accepte des chiffres, un signe moins facultatif et un point décimal.

<code>1710000000.5</code> donne <code>16:00:00.500</code> UTC. La fonction <code>time.time()</code> de Python renvoie ce genre de valeur, avec une fraction de seconde
Les chiffres au-delà de la milliseconde sont coupés et non arrondis. Par exemple, <code>1710000000.123456</code> donne <code>16:00:00.123</code>
<code>0</code> est le 1er janvier 1970 à 00:00:00 UTC, <code>-1</code> le 31 décembre 1969 à 23:59:59 et <code>-86400</code> le 31 décembre 1969 à 00:00:00. POSIX laisse les valeurs négatives indéfinies, mais JavaScript et Python les gèrent
Une virgule décimale (<code>1710000000,5</code>), un exposant (<code>1e9</code>) et une valeur hexadécimale provoquent le message « Impossible d’analyser cette entrée »
Le même instant dans quatre fuseaux

Prenons 1710000000. L’epoch ne change pas, seule sa lecture change. Réglez Fuseau sur Local pour voir la ligne de votre propre fuseau.

UTC : samedi 9 mars 2024 à 16:00:00
Paris : 17:00:00, UTC+1 (heure d’hiver jusqu’au 31 mars 2024)
New York : 11:00:00, UTC-5. Les États-Unis sont passés à l’heure d’été le lendemain, 10 mars 2024, et New York est à UTC-4 depuis
Tokyo : dimanche 10 mars 2024 à 01:00:00, UTC+9. Le fuseau déplace aussi le jour, ce qui compte quand vous découpez des logs par jour
Le champ Date/heure locale suit toujours l’horloge murale de votre navigateur, même quand le tableau est réglé sur UTC. Une aide sous le champ le rappelle
Le texte d’une date, avec ou sans fuseau

Saisissez une date dans le champ ISO / texte date pour obtenir son epoch. Le résultat dépend de ce que vous avez écrit après l’heure. Les valeurs suivantes ont été vérifiées dans Node 26, qui utilise le même moteur JavaScript que Chrome. D’autres navigateurs peuvent lire autrement les formes qui ne sont pas ISO.

<code>2024-03-09T16:00:00Z</code> donne <code>1710000000</code> dans tous les fuseaux de navigateur, parce que le <code>Z</code> dit UTC
<code>2024-03-09T16:00:00+01:00</code> donne <code>1709996400</code>, soit 15:00 UTC
<code>2024-03-09T16:00:00</code> n’a pas de décalage et se lit dans le fuseau du navigateur : <code>1710000000</code> en UTC, <code>1709996400</code> à Paris, <code>1710018000</code> à New York et <code>1709967600</code> à Tokyo
<code>2024-03-09</code>, une date seule, se lit comme minuit UTC : <code>1709942400</code> dans tous les fuseaux. Ajouter une heure sans décalage change la règle
<code>2024-03-09 16:00:00</code> avec une espace et <code>March 9, 2024</code> ne sont pas des formes ISO. Le moteur testé ici les lit en heure locale, et la norme laisse la règle à chaque moteur
<code>09/03/2024</code> se lit avec le mois en premier, comme le 3 septembre 2024. Un format avec le jour en premier doit être réécrit en ISO
<code>Sat, 09 Mar 2024 16:00:00 GMT</code>, la forme RFC 2822 des en-têtes HTTP, est comprise et donne <code>1710000000</code>

Cinq erreurs qu’on ne voit qu’en production

Confondre secondes et millisecondes à la frontière entre deux systèmes

JavaScript compte en millisecondes, la plupart des autres langages et protocoles en secondes. new Date(1710000000) donne le 20 janvier 1970 à 19:00:00 UTC. En Python 3.14, datetime.fromtimestamp(1710000000000, tz=timezone.utc) s’arrête avec year must be in 1..9999, not 56157. Java a deux méthodes, Instant.ofEpochSecond et Instant.ofEpochMilli, et rien ne vous prévient si vous prenez la mauvaise.

Passer le résultat de <code>Date.now()</code> à une fonction qui attend des secondes, ou celui de <code>time()</code> à <code>new Date()</code>
Diviser par 1000 deux fois, ou jamais, le long d’une chaîne de trois services
Stocker des millisecondes dans une colonne d’entier sur 32 bits, qui ne dépasse pas 2 147 483 647
Lire des nanosecondes avec <code>JSON.parse</code> : 1710000000123456789 revient sous la forme 1710000000123456800, car les nombres JavaScript ne sont exacts que jusqu’à 9 007 199 254 740 991. Lisez le champ comme une chaîne ou un BigInt
Comparer un champ en secondes à un champ en millisecondes, et obtenir un résultat toujours vrai ou toujours faux
Écrivez l’unité dans le nom (<code>created_at_ms</code>, <code>expires_in_s</code>) et dans la description de l’API, et testez avec une valeur que vous savez lire, comme l’epoch d’aujourd’hui à midi.
Un JWT qui expire dans plus de 50 000 ans

La RFC 7519 définit exp, nbf et iat comme un nombre de secondes depuis l’epoch, sans compter les secondes intercalaires. Un jeton signé avec exp réglé sur Date.now() + 3600000 porte des millisecondes. Avec la bibliothèque jose en version 6, un tel jeton signé le 9 mars 2024 était encore accepté quand la date de contrôle valait 2034. Son exp de 1710003600000, lu en secondes, correspond à +056157-11-09T08:00:00.000Z. Le convertisseur cache l’erreur si vous laissez l’unité sur Auto, parce qu’il lit 13 chiffres comme des millisecondes et affiche une date normale.

Régler <code>exp</code> depuis une horloge en millisecondes, comme dans <code>Date.now() + 3600 * 1000</code>
Coller <code>exp</code> dans le convertisseur avec l’unité sur Auto, et conclure que la date est bonne
Faire confiance au vérificateur : il compare des nombres et ne peut pas savoir quelle unité vous aviez en tête
Mélanger <code>iat</code> en secondes et <code>exp</code> en millisecondes dans le même payload, si bien que le jeton semble vivre pour toujours
Décodez le jeton, puis collez <code>exp</code> avec l’unité réglée sur Secondes. Une date de 2026 est juste. Une date après l’an 3000 est une erreur.
Lire une date sans fuseau

Le texte d’une date sans décalage ne désigne aucun instant tant qu’on n’a pas choisi de fuseau. En Python, datetime(2024, 3, 9, 16, 0, 0).timestamp() sur une machine réglée sur Paris donne 1709996400, pas 1710000000. JavaScript lit 2024-03-09 comme minuit UTC, mais 2024-03-09T00:00:00 comme minuit en heure locale : deux écritures du même jour diffèrent du décalage de la machine.

Stocker une heure murale locale comme si c’était de l’UTC, puis l’afficher à des utilisateurs d’un autre fuseau
Obtenir un epoch différent pour la même chaîne sur un portable à Paris et sur un serveur en UTC
Découper des logs par jour en UTC alors que les lecteurs travaillent dans un autre fuseau : <code>1710000000</code> est déjà le 10 à Tokyo
Écrire une date sans fuseau dans une fixture, si bien qu’un test passe dans un pays et échoue dans un autre
Écrivez le décalage ou un <code>Z</code> sur chaque date que vous échangez. Stockez l’epoch ou la date UTC, et n’appliquez un fuseau qu’à l’affichage.
Se fier à une heure locale à travers un changement d’heure

L’Europe repasse à l’heure d’hiver le dimanche 25 octobre 2026, à 01:00 UTC. À Paris, 03:00 redevient 02:00 : 02:30 existe donc deux fois, à 00:30 UTC (1792888200) et à 01:30 UTC (1792891800). Avec un navigateur réglé sur Paris, le champ Date/heure locale prend la première. Le 29 mars 2026, l’heure de 02:00 à 03:00 n’existe pas, et le champ répond qu’il ne peut pas analyser 02:30. L’epoch lève le doute, car il désigne un seul instant.

Ajouter 86 400 secondes pour obtenir « la même heure demain ». À partir de 09:00 à Paris le 24 octobre 2026, on obtient 08:00 le 25, car ce jour dure 25 heures
Stocker une heure locale sans son décalage, et trouver deux epochs possibles après le retour à l’heure d’hiver
Planifier une tâche à 02:30 en heure locale et la voir partir deux fois, ou jamais (le guide cron traite ce cas)
Croire que deux heures locales distantes de 24 heures sont toujours distantes de 86 400 secondes
Faites les calculs sur des epochs ou des dates UTC, et convertissez en heure locale seulement pour l’affichage. Prenez une bibliothèque de dates quand il vous faut « la même heure demain ».
Oublier les limites du format

Un epoch se stocke facilement et déborde facilement. Ces limites viennent de la largeur du type qui le contient.

Garder un epoch dans un entier signé sur 32 bits : la dernière seconde est <code>2147483647</code>, le 19 janvier 2038 à 03:14:07 UTC. Une seconde plus tard, le compteur repasse sur une date de 1901
Utiliser une colonne MySQL <code>TIMESTAMP</code> pour une date après 2038 : la documentation donne '2038-01-19 03:14:07' UTC comme borne haute
Prendre un entier non signé sur 32 bits pour une solution sûre : il s’arrête à <code>4294967295</code>, et <code>4294967296</code> est le 7 février 2106 à 06:28:16 UTC
Compter sur les secondes intercalaires : le temps Unix compte chaque jour pour exactement 86 400 secondes, donc l’écart entre deux epochs peut être inférieur d’une seconde au temps réellement écoulé
Utilisez un entier sur 64 bits ou un type de date natif, et testez les valeurs limites <code>2147483647</code> et <code>4294967296</code> dans le convertisseur.

Unités, limites et autres epochs en un coup d’œil

L’unité de chaque système

Lisez la documentation du système qui a produit le nombre avant de vous fier à ses chiffres.

JavaScript : <code>Date.now()</code> et <code>getTime()</code> renvoient un nombre de millisecondes
Python : <code>time.time()</code> renvoie des secondes sous forme de flottant, et <code>time.time_ns()</code> des nanosecondes
Java : <code>System.currentTimeMillis()</code> renvoie un nombre de millisecondes, alors que <code>Instant.getEpochSecond()</code> renvoie un nombre de secondes
PHP : <code>time()</code> renvoie un nombre de secondes, alors que <code>microtime(true)</code> renvoie ce nombre avec une fraction
Shell : <code>date +%s</code> affiche un nombre de secondes. La version GNU de <code>date</code> affiche aussi les millisecondes avec <code>date +%s%3N</code>
JWT : <code>exp</code>, <code>nbf</code> et <code>iat</code> sont toujours en secondes, et la RFC 7519 admet une fraction
Le convertisseur FastMinify : des secondes jusqu’à 10 chiffres, des millisecondes de 11 à 15 chiffres, un refus à partir de 16 chiffres
Des nombres à connaître

Ces valeurs se reconnaissent vite quand on les a vues, et chacune peut être collée dans le convertisseur.

<code>0</code> : 1er janvier 1970 à 00:00:00 UTC, l’origine
<code>1000000000</code> : 9 septembre 2001 à 01:46:40 UTC, le premier epoch à 10 chiffres
<code>2147483647</code> : 19 janvier 2038 à 03:14:07 UTC, la fin d’un entier signé sur 32 bits
<code>4294967296</code> : 7 février 2106 à 06:28:16 UTC, un cran après la fin d’un entier non signé sur 32 bits
<code>9999999999</code> : 20 novembre 2286 à 17:46:39 UTC, le dernier epoch à 10 chiffres
<code>8640000000000</code> secondes : 13 septembre 275760, la dernière date qu’un <code>Date</code> JavaScript peut contenir. Avec l’unité réglée sur Secondes, l’outil l’accepte et refuse une seconde de plus
Les epochs qui ne partent pas de 1970

Certains systèmes comptent depuis une autre origine ou dans une autre unité. Si une date est décalée de plusieurs décennies, cherchez l’un de ces cas.

FILETIME de Windows : pas de 100 nanosecondes depuis le 1er janvier 1601. Le décalage avec Unix est de 11 644 473 600 secondes. Pour <code>1710000000</code>, le FILETIME vaut 133544736000000000, soit 18 chiffres, et le convertisseur le refuse
Temps absolu d’Apple (Core Data, Cocoa) : secondes depuis le 1er janvier 2001, soit un décalage de 978 307 200 secondes. <code>1710000000</code> devient 731692800
Temps GPS : secondes depuis le 6 janvier 1980, soit un décalage de 315 964 800 secondes. Il ne tient pas compte des secondes intercalaires, si bien que l’écart avec l’UTC grandit avec le temps
Ticks .NET : pas de 100 nanosecondes depuis le 1er janvier de l’an 1. L’epoch Unix se trouve à 62 135 596 800 secondes de cette origine
Dates série d’Excel et de Google Sheets : jours depuis le 30 décembre 1899 dans le système par défaut. Le 1er janvier 1970 est le jour 25 569, et <code>1710000000</code> vaut 45360,67 (la fraction donne l’heure)

Le convertisseur de timestamp Unix, pas à pas

Lire un epoch

Le convertisseur de timestamp Unix se met à jour peu après la dernière frappe. Il n’y a pas de bouton Convertir.

1

Regarder l’horloge en direct

Le bloc « Heure Unix actuelle » affiche l’epoch en Secondes et en Millisecondes, chacun avec un bouton Copier. Pause arrête l’horloge et Reprendre la relance. Copier ISO (UTC) prend la date du moment.

2

Saisir ou coller l’epoch

Utilisez le champ Epoch Unix. Un badge comme « Déduit : secondes » montre comment les chiffres ont été lus. Vous pouvez forcer Secondes ou Millisecondes avec l’option Unité.

3

Lire le tableau Formats

Il liste l’epoch en secondes et en millisecondes, l’ISO 8601, la RFC 2822 et un datetime SQL. Il ajoute une chaîne locale dans la langue de la page et un temps relatif. La RFC 2822 utilise les noms de jours et de mois en anglais. La ligne relative compte un mois pour 30 jours et une année pour 365 : c’est un repère approximatif.

4

Copier la ligne voulue

Chaque ligne a son propre bouton Copier. Un court message confirme ce qui a été copié.

Partir d’une date

Les trois champs restent synchronisés. Celui que vous modifiez commande les autres.

1

ISO / texte date

Saisissez 2024-03-09T16:00:00Z pour obtenir l’epoch. Le champ Epoch Unix se remplit en secondes, ou en millisecondes si l’unité est réglée sur Millisecondes.

2

Date/heure locale

Utilisez ce champ pour entrer une date sur votre horloge murale. Ce n’est jamais de l’UTC, même quand le tableau affiche l’UTC, et une aide sous le champ le dit.

3

Vérifier le fuseau voulu

Si le texte ISO n’a ni Z ni décalage, le navigateur applique son propre fuseau. Ajoutez le décalage pour que le résultat soit le même sur toutes les machines.

Régler les options

Deux réglages changent la façon dont la page lit et affiche une valeur.

1

Unité

Le mode Auto lit jusqu’à 10 chiffres comme des secondes et de 11 à 15 chiffres comme des millisecondes. Secondes et Millisecondes forcent la lecture. Prenez Secondes pour les claims d’un JWT.

2

Fuseau

UTC est le réglage par défaut. Local utilise le fuseau de votre navigateur et change les lignes ISO, RFC 2822, SQL et chaîne locale. Les lignes d’epoch ne changent jamais.

3

Exemple et Tout effacer

Exemple saisit 1710000000. Tout effacer vide les champs et ramène l’horloge en direct.

Comprendre un refus

Quand une valeur est illisible, l’outil dit pourquoi et n’affiche aucune date.

1

Impossible d’analyser cette entrée

Le texte n’est ni un nombre ni une date que le navigateur comprend. Réécrivez la date en ISO 8601, par exemple 2024-03-09T16:00:00+00:00.

2

Cette valeur semble plus précise que des millisecondes

Le nombre a 16 chiffres ou plus, comme des microsecondes, des nanosecondes ou un FILETIME. Retirez d’abord les chiffres en trop.

Les mêmes conversions en JavaScript, en Python, dans un shell et en Java

JavaScript

JavaScript travaille en millisecondes. Multipliez ou divisez par 1000 à la frontière avec les systèmes en secondes, et donnez un fuseau à Intl.DateTimeFormat quand il vous en faut un nommé.

Exemple de base

const epochSeconds = 1710000000 // Seconds -> Date: multiply by 1000 new Date(epochSeconds * 1000).toISOString() // 2024-03-09T16:00:00.000Z new Date(epochSeconds).toISOString() // 1970-01-20T19:00:00.000Z (seconds read as milliseconds) // Date -> seconds: divide by 1000 and round down Math.floor(Date.parse('2024-03-09T16:00:00Z') / 1000) // 1710000000 // A named zone for display. The epoch does not change. const fmt = new Intl.DateTimeFormat('fr-FR', { timeZone: 'Asia/Tokyo', dateStyle: 'medium', timeStyle: 'long', }) fmt.format(epochSeconds * 1000) // 10 mars 2024, 01:00:00 UTC+9 // Date alone is UTC, date with a time and no offset is local Date.parse('2024-03-09') // 1709942400000 in every zone Date.parse('2024-03-09T16:00:00') // depends on the zone of the machine
Python

Passez un fuseau à chaque appel. Un datetime naïf n’en a pas, et timestamp() utilise alors le fuseau de la machine.

Exemple de base

import time from datetime import datetime, timezone from zoneinfo import ZoneInfo ts = 1710000000 datetime.fromtimestamp(ts, tz=timezone.utc).isoformat() # '2024-03-09T16:00:00+00:00' datetime.fromtimestamp(ts, tz=ZoneInfo('America/New_York')).isoformat() # '2024-03-09T11:00:00-05:00' # Milliseconds: divide first, or Python raises ValueError (year out of range) datetime.fromtimestamp(1710000000000 / 1000, tz=timezone.utc) # Date -> epoch, with the zone written down int(datetime(2024, 3, 9, 16, 0, 0, tzinfo=timezone.utc).timestamp()) # 1710000000 # Without tzinfo the result depends on the machine (TZ=Europe/Paris gives 1709996400) int(datetime(2024, 3, 9, 16, 0, 0).timestamp()) time.time() # a float in seconds, for example 1792398878.41
Un shell

Les versions GNU et BSD de date, la première sous Linux et la seconde sous macOS, n’ont pas les mêmes options.

Exemple de base

# Current epoch in seconds (GNU and macOS) date +%s # Epoch -> date, GNU date (Linux) date -u -d @1710000000 +%Y-%m-%dT%H:%M:%SZ # 2024-03-09T16:00:00Z TZ=Europe/Paris date -d @1710000000 +%FT%T%z # 2024-03-09T17:00:00+0100 # Epoch -> date, BSD date (macOS) date -u -r 1710000000 +%Y-%m-%dT%H:%M:%SZ # 2024-03-09T16:00:00Z # Milliseconds, GNU date only date +%s%3N
Java

L’API java.time garde l’unité dans le nom de la méthode, ce qui rend une confusion visible en revue de code.

Exemple de base

import java.time.*; Instant.ofEpochSecond(1710000000L); // 2024-03-09T16:00:00Z Instant.ofEpochMilli(1710000000000L); // 2024-03-09T16:00:00Z Instant.ofEpochSecond(1710000000L) .atZone(ZoneId.of("Europe/Paris")); // 2024-03-09T17:00+01:00[Europe/Paris] Instant.parse("2024-03-09T16:00:00Z").getEpochSecond(); // 1710000000

Conclusion

Un epoch désigne un seul instant, et presque toutes les erreurs viennent de la façon de le lire. Comptez les chiffres pour distinguer secondes et millisecondes, écrivez le décalage sur chaque date, et gardez le fuseau pour l’affichage. Le convertisseur de timestamp Unix montre le même instant dans les formats utiles, en UTC ou dans votre fuseau. Il lit une valeur à la fois, n’offre pas de liste de fuseaux et refuse les valeurs de 16 chiffres ou plus. Pour un jeton, lisez ses claims avec le décodeur JWT et collez exp avec l’unité réglée sur Secondes. Pour un log, réécrivez d’abord la date en ISO 8601. Le hub des utilitaires développeur liste les outils voisins.

Convertir un timestamp Unix dans votre navigateur

Comptez les chiffres : 10 pour des secondes, 13 pour des millisecondes, et méfiez-vous de toute date en 1970 ou après l’an 3000
Écrivez le décalage ou un Z sur chaque date que vous stockez ou envoyez
Faites les calculs sur des epochs ou des dates UTC, et convertissez en heure locale seulement pour l’affichage
Réglez l’unité sur Secondes pour contrôler les claims d’un JWT
Utilisez un entier sur 64 bits, et testez les valeurs 2147483647 et 4294967296
Partager cet article
Partager cet article: