Formats de timestamp Unix expliqués

Tous les formats de timestamp Unix d'un coup d'œil

Un timestamp Unix n'est qu'un nombre, et son format n'est en réalité que son unité — la finesse avec laquelle il compte depuis le 1er janvier 1970 UTC. L'unité est presque toujours lisible au nombre de chiffres : 10 chiffres sont des secondes, 13 des millisecondes, 16 des microsecondes, 19 des nanosecondes. Les deux formats de chaîne, ISO 8601 et RFC 2822, sont au contraire auto-descriptifs. Le tableau ci-dessous est tout le paysage ; les sections qui suivent couvrent chaque format et comment les distinguer.

Le temps Unix en secondes — le format universel

Le format le plus courant : un entier 32 bits ou 64 bits comptant le nombre de secondes entières depuis le 1er janvier 1970 00:00:00 UTC. Actuellement un nombre de 10 chiffres autour de 1,7 milliard.

• Exemple : 1700000000 = 2023-11-15 06:13:20 UTC
• Utilisé par : Python time.time(), PHP time(), Go time.Now().Unix(), Ruby Time.now.to_i, C time(NULL)
• Stocké comme : int 32 bits (ancien, an max 2038), int 64 bits (moderne, sûr pour des milliards d'années)
• Base de données : MySQL UNIX_TIMESTAMP(), PostgreSQL EXTRACT(EPOCH FROM NOW())::BIGINT

• The Open Group — Seconds Since the Epoch (POSIX)

Le temps Unix en millisecondes — le format de JavaScript

Millisecondes depuis l'epoch Unix : un entier de 13 chiffres offrant une précision à la milliseconde. C'est le format que l'objet Date de JavaScript utilise en interne.

• Exemple : 1700000000000 = 2023-11-15 06:13:20.000 UTC
• Utilisé par : JavaScript Date.now(), Java System.currentTimeMillis(), .NET DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
• Convertir en secondes : Math.floor(ms / 1000)
• Convertir depuis les secondes : seconds * 1000

• MDN — Date.now() et l'objet Date
• Millisecondes vs secondes — quand utiliser quoi

ISO 8601 — le standard lisible par l'humain

ISO 8601 est un standard international pour représenter les dates et heures sous forme de chaînes. Contrairement aux timestamps Unix, il est auto-descriptif : le format encode à la fois la date/heure et le décalage de fuseau.

• 2023-11-15T06:13:20Z — UTC (le suffixe Z signifie UTC)
• 2023-11-15T01:13:20-05:00 — avec décalage UTC explicite (EST)
• 2023-11-15T06:13:20.000Z — avec millisecondes
• JavaScript : date.toISOString() renvoie toujours l'UTC avec le suffixe Z
• Python : datetime.isoformat(), Go : time.Format(time.RFC3339)

• ISO 8601 et RFC 3339 — le guide complet du format

RFC 2822 — format de date e-mail et HTTP

RFC 2822 (mis à jour par RFC 5322 pour l'e-mail, et reflété par RFC 9110 pour HTTP) est le format de date lisible utilisé dans les en-têtes d'e-mail et les réponses HTTP. Le Date.toUTCString() de JavaScript renvoie ce format.

• Exemple : Wed, 15 Nov 2023 06:13:20 GMT
• Utilisé dans : les en-têtes de réponse HTTP (Last-Modified, Date, Expires), les en-têtes d'e-mail (Date:)
• JavaScript : date.toUTCString()
• Moins courant dans les API modernes mais encore largement rencontré dans l'infrastructure web

• RFC 5322 — Internet Message Format (l'en-tête de date)

Comment détecter le format du timestamp

Quand tu reçois une valeur de timestamp inconnue, ces règles identifient son format. Le nombre de chiffres tranche chaque cas numérique ; les deux formats de chaîne sont évidents à vue.

• Vérification de bon sens : toute valeur numérique devrait décoder en une date crédible de l'ère actuelle (environ 2001–2038 pour des secondes à 10 chiffres)
• Une date proche de 1970 ou à des milliers d'années signifie que l'unité a été mal lue

Microsecondes et nanosecondes

Certains systèmes de haute précision utilisent des unités plus petites que la milliseconde. Elles sont rares dans le code applicatif mais apparaissent dans les systèmes bas niveau, les internes de base de données et les outils d'observabilité.

• Microsecondes (µs) : entier de 16 chiffres — Rust SystemTime as_micros(), PostgreSQL clock_gettime()
• Nanosecondes (ns) : entier de 19 chiffres — Go time.Now().UnixNano(), Rust SystemTime as_nanos()
• PostgreSQL EXTRACT(EPOCH) renvoie un nombre à virgule flottante avec les microsecondes en partie fractionnaire
• Convertir des nanosecondes en secondes : diviser par 1 000 000 000 (1e9)

Résolution et précision des fractions de seconde

Chaque format ci-dessus porte une résolution temporelle différente. Choisir un format, c'est choisir avec quelle finesse tu peux distinguer deux moments — d'une seconde à une nanoseconde.

• Résolution à 1 seconde : secondes Unix (10 chiffres), POSIX time_t traditionnel
• 1 milliseconde : JavaScript Date, MongoDB BSON Date, Java Instant.toEpochMilli()
• 1 microseconde : timestamps Chrome/WebKit, Python datetime.timestamp(), PostgreSQL timestamp precision 6
• 100 nanosecondes : Windows FILETIME, .NET DateTime.Ticks
• 1 nanoseconde : Java Instant (précision complète), Go time.UnixNano(), JS Temporal.Instant.epochNanoseconds (BigInt)
• Picoseconde et au-dessous : format filaire PTP/IEEE 1588 (1/2^32 de seconde), champ fraction de NTP
• Choisis la résolution la plus grossière qui répond à tes besoins — la précision infra-seconde est souvent perdue à la sérialisation JSON ou au round-trip de chaîne
• Pour convertir entre formats, passe par les millisecondes ou nanosecondes Unix (via BigInt) — c'est le plus petit dénominateur commun qui préserve la précision

Convertisseurs de format de timestamp

Convertis entre le temps Unix et les formats de timestamp spécifiques aux plateformes que tu rencontres dans la nature :

• Convertisseur FILETIME
• Convertisseur de Ticks .NET
• Temps WebKit/Chrome
• Mac Absolute Time
• Timestamp Core Data
• Convertisseur de date Excel
• Timestamp NTP
• Convertisseur de temps GPS
• Convertisseur de jour julien