Convertisseur d'Horodatage

Qu'est-ce qu'un horodatage Unix ?

Un horodatage Unix (aussi appelé epoch time ou POSIX time) est le nombre de secondes écoulées depuis le 1er janvier 1970, 00:00:00 UTC. Cette date est appelée l'époque Unix. Chaque seconde qui passe incrémente le compteur d'une unité, donnant à chaque instant une représentation entière unique. Un convertisseur d'horodatage Unix traduit cet entier en formats de date lisibles comme ISO 8601, RFC 2822, ou des chaînes propres à chaque locale.

Les horodatages Unix sont la méthode standard pour représenter le temps en informatique. Les bases de données stockent les colonnes created_at et updated_at sous forme d'entiers ou d'horodatages en millisecondes. Les réponses API incluent des horodatages pour les en-têtes de cache (Expires, Last-Modified), les claims JWT (iat, exp, nbf) et les journaux d'événements. Les fichiers de log de nginx, syslog et des frameworks applicatifs utilisent tous l'epoch time. Le format est non ambigu car il représente toujours UTC, sans décalage de fuseau horaire ni d'heure d'été à interpréter.

Convertir manuellement entre horodatages et dates est source d'erreurs. Une valeur comme 1711324800 ne donne aucun indice visuel sur la date qu'elle représente. Cet outil convertit les horodatages Unix en dates lisibles et les dates en horodatages. Que vous lisiez un claim JWT exp, déboguiez une requête de base de données ou consultiez un horodatage de log, il gère automatiquement les valeurs à 10 chiffres (secondes) et 13 chiffres (millisecondes).

Pourquoi utiliser ce convertisseur d'horodatage ?

Lire des horodatages Unix bruts depuis des logs, des bases de données ou des réponses API nécessite soit de mémoriser les calculs d'époque, soit d'écrire du code jetable. Ce convertisseur le fait dans votre navigateur sans aucune configuration. Que vous ayez besoin de décoder une expiration JWT, d'auditer une ligne de log ou de définir un TTL de base de données, le résultat est à portée d'un clic. L'outil détecte automatiquement si une valeur est un horodatage en secondes à 10 chiffres ou en millisecondes à 13 chiffres, vous n'avez donc jamais besoin de diviser manuellement par 1000. Tout le traitement s'effectue localement dans votre navigateur. Aucune donnée ne quitte votre machine, les horodatages des systèmes internes et des logs sensibles restent privés.

Cas d'usage du convertisseur d'horodatage

Table de référence des horodatages Unix

Le tableau ci-dessous présente des horodatages Unix bien connus et les dates correspondantes. Ces valeurs sont utiles pour des vérifications rapides, les tests et la compréhension de la plage des horodatages 32 bits et 64 bits.

Comparaison des formats de date et d'heure

Différents systèmes et standards représentent le même instant avec des formats de chaîne différents. Le tableau compare les formats les plus courants que vous rencontrerez dans les APIs, les logs et les bases de données.

Exemples de code

Convertissez entre horodatages Unix et dates dans le langage avec lequel vous travaillez. Chaque exemple présente les deux directions : horodatage vers date et date vers horodatage.

// Current Unix timestamp in seconds
Math.floor(Date.now() / 1000)  // → 1711324800

// Unix timestamp to Date object
const date = new Date(1711324800 * 1000)
date.toISOString()             // → "2024-03-25T00:00:00.000Z"
date.toUTCString()             // → "Mon, 25 Mar 2024 00:00:00 GMT"

// Date string to Unix timestamp
Math.floor(new Date('2024-03-25T00:00:00Z').getTime() / 1000)
// → 1711324800

// Millisecond timestamps (common in JS APIs)
Date.now()                     // → 1711324800000 (ms)
Date.parse('2024-03-25')       // → 1711324800000 (ms)

import time
from datetime import datetime, timezone

# Current Unix timestamp
int(time.time())                                    # → 1711324800

# Unix timestamp to datetime
dt = datetime.fromtimestamp(1711324800, tz=timezone.utc)
dt.isoformat()                                      # → '2024-03-25T00:00:00+00:00'
dt.strftime('%Y-%m-%d %H:%M:%S %Z')                 # → '2024-03-25 00:00:00 UTC'

# Datetime string to Unix timestamp
dt = datetime.fromisoformat('2024-03-25T00:00:00+00:00')
int(dt.timestamp())                                  # → 1711324800

# Parse RFC 2822 dates (from email headers)
from email.utils import parsedate_to_datetime
parsedate_to_datetime('Mon, 25 Mar 2024 00:00:00 +0000').timestamp()
# → 1711324800.0

package main

import (
    "fmt"
    "time"
)

func main() {
    // Current Unix timestamp
    now := time.Now().Unix() // → 1711324800

    // Unix timestamp to time.Time
    t := time.Unix(1711324800, 0).UTC()
    fmt.Println(t.Format(time.RFC3339))
    // → 2024-03-25T00:00:00Z

    // Parse a date string to Unix timestamp
    parsed, _ := time.Parse(time.RFC3339, "2024-03-25T00:00:00Z")
    fmt.Println(parsed.Unix())
    // → 1711324800

    // Millisecond timestamp
    ms := time.Now().UnixMilli() // → 1711324800000
    fmt.Println(now, ms)
}

# Current Unix timestamp
date +%s                                    # → 1711324800

# Convert timestamp to human-readable date (GNU date)
date -d @1711324800                         # → Mon Mar 25 00:00:00 UTC 2024

# Convert timestamp to ISO 8601
date -d @1711324800 --iso-8601=seconds      # → 2024-03-25T00:00:00+00:00

# macOS (BSD date) — slightly different flags
date -r 1711324800                          # → Mon Mar 25 00:00:00 UTC 2024

# Date string to timestamp (GNU date)
date -d "2024-03-25 00:00:00 UTC" +%s       # → 1711324800

Questions fréquentes