🕐
← Retour aux guides

Comment convertir plusieurs horodatages Unix à la fois

· Tags: batch-processing, log-analysis, automation, unix-timestamp, shell-scripting, data-processing

Pourquoi convertir des horodatages par lots ?

Lorsque vous travaillez avec des journaux serveur, des exports de bases de données, des réponses d'API ou des ensembles de données analytiques, vous rencontrez rarement un seul horodatage à la fois. Les données du monde réel contiennent souvent des milliers ou des millions d'horodatages Unix répartis dans des fichiers, des colonnes ou des payloads JSON. Convertir manuellement chacun d'eux est irréaliste. Le traitement par lots transforme des montagnes de nombres bruts en chronologies lisibles.

Ce guide couvre des approches pratiques pour convertir plusieurs horodatages à l'aide d'outils en ligne de commande, de scripts et de notre outil en ligne.

Méthode 1 : Utiliser le convertisseur par lots en ligne

Notre Convertisseur d'horodatage Unix prend en charge la saisie par lots. Collez plusieurs horodatages (un par ligne ou séparés par des virgules) et l'outil les convertit tous à la fois, affichant les résultats dans un tableau trié par fuseau horaire.

C'est idéal pour des lots de taille modérée — des dizaines à des centaines d'horodatages — où vous avez besoin d'un résultat rapide et visuel sans écrire de code.

Méthode 2 : Traitement par lots en ligne de commande

Boucle de base avec la commande date

# Convert a list of timestamps using a bash loop
for ts in 1785292800 1785379200 1785465600 1785552000; do
    date -d @"$ts" "+%Y-%m-%d %H:%M:%S"
done

Lecture à partir d'un fichier

# timestamps.txt contains one timestamp per line
while read -r ts; do
    date -d @"$ts" "+%Y-%m-%d %H:%M:%S"
done < timestamps.txt

Utiliser xargs pour le traitement parallèle

# For large files, use xargs with multiple processes
cat timestamps.txt | xargs -P 4 -I {} date -d "@{}" "+%Y-%m-%d %H:%M:%S"

Sortie vers un fichier CSV

# Generate a CSV with original timestamp and converted date
echo "timestamp,date_utc,date_local" > output.csv
while read -r ts; do
    utc_date=$(TZ=UTC date -d @"$ts" "+%Y-%m-%d %H:%M:%S")
    local_date=$(date -d @"$ts" "+%Y-%m-%d %H:%M:%S")
    echo "$ts,$utc_date,$local_date" >> output.csv
done < timestamps.txt

Méthode 3 : Extraire les horodatages des fichiers journaux

Les fichiers journaux contiennent souvent des horodatages intégrés dans du texte structuré ou semi-structuré. Voici des techniques pratiques pour les formats de journaux courants.

Journaux d'accès Apache / Nginx

Les journaux Apache et Nginx utilisent souvent le format %{%Y-%m-%d}T ou, s'ils sont configurés, des horodatages Unix :

# Extract and convert timestamps from an Nginx log
# The log lines might contain: [1785292800] GET /index.html 200
grep -oP '\[\K[0-9]{10}(?=\])' access.log | while read -r ts; do
    date -d @"$ts" "+%Y-%m-%d %H:%M:%S"
done

Journaux JSON

Les applications modernes journalisent souvent au format JSON :

# Using jq to extract timestamps from a JSON log file
cat app.log | jq -r '.timestamp' | while read -r ts; do
    date -d @"$ts" "+%Y-%m-%d %H:%M:%S"
done

Journaux à délimiteur personnalisé

# If timestamps are the first field in a log (pipe-delimited)
awk -F'|' '{ts=$1; cmd="date -d @" ts " \"+%Y-%m-%d %H:%M:%S\""; cmd | getline date; close(cmd); print date, $0}' server.log

Méthode 4 : Utiliser Python pour un traitement par lots avancé

Python est l'outil le plus flexible pour la conversion par lots, en particulier lorsque les horodatages nécessitent un filtrage, une transformation ou un export.

Convertir une liste d'horodatages

from datetime import datetime
import json

timestamps = [1785292800, 1785379200, 1785465600, 1785552000]

results = []
for ts in timestamps:
    dt = datetime.utcfromtimestamp(ts)
    results.append({
        "timestamp": ts,
        "datetime_utc": dt.strftime("%Y-%m-%d %H:%M:%S"),
        "date": dt.strftime("%Y-%m-%d"),
        "time": dt.strftime("%H:%M:%S"),
        "day_of_week": dt.strftime("%A"),
    })

print(json.dumps(results, indent=2))

Traiter un fichier CSV

import csv
from datetime import datetime

with open("data.csv", "r") as infile, open("converted.csv", "w", newline="") as outfile:
    reader = csv.DictReader(infile)
    writer = csv.DictWriter(outfile, fieldnames=reader.fieldnames + ["date_utc", "date_local"])
    writer.writeheader()
    
    for row in reader:
        ts = int(row["timestamp"])
        dt_utc = datetime.utcfromtimestamp(ts)
        row["date_utc"] = dt_utc.strftime("%Y-%m-%d %H:%M:%S")
        
        # You can replace this with your local timezone
        from datetime import timezone
        dt_local = datetime.fromtimestamp(ts, tz=timezone.utc).astimezone()
        row["date_local"] = dt_local.strftime("%Y-%m-%d %H:%M:%S %Z")
        
        writer.writerow(row)

print("Conversion complete. Output written to converted.csv")

Filtrer par plage de dates

from datetime import datetime

# Define the range: start and end of July 2026
start_ts = int(datetime(2026, 7, 1).timestamp())
end_ts   = int(datetime(2026, 7, 31, 23, 59, 59).timestamp())

timestamps = [1785292800, 1785379200, 1785465600, 1785552000,
              1234567890, 1000000000]

# Filter to July 2026 only
july_only = [ts for ts in timestamps if start_ts <= ts <= end_ts]

for ts in july_only:
    dt = datetime.utcfromtimestamp(ts)
    print(f"{ts} -> {dt.strftime('%Y-%m-%d %H:%M:%S')}")

Méthode 5 : Utiliser awk pour la conversion en flux

Pour les très grands fichiers (des millions de lignes), awk traite les données en flux sans tout charger en mémoire :

#!/usr/bin/awk -f
# batch-convert.awk
# Converts first field as Unix timestamp, prints all fields with date

{
    ts = $1
    # awk's mktime expects "YYYY MM DD HH MM SS"
    # We call the shell for conversion via date command
    cmd = "date -d @" ts " \"+%Y-%m-%d %H:%M:%S\""
    cmd | getline date
    close(cmd)
    print date, $0
}

Utilisation :

./batch-convert.awk server.log

Méthode 6 : Utiliser SQL pour les horodatages en base de données

Si vos horodatages sont dans une base de données, laissez SQL faire le travail :

PostgreSQL

SELECT 
    id,
    event_time,
    to_timestamp(event_time) AS readable_time,
    to_char(to_timestamp(event_time), 'YYYY-MM-DD HH24:MI:SS') AS formatted_time
FROM events
WHERE to_timestamp(event_time) >= '2026-07-01';

MySQL

SELECT 
    id,
    event_time,
    FROM_UNIXTIME(event_time) AS readable_time,
    FROM_UNIXTIME(event_time, '%Y-%m-%d %H:%i:%s') AS formatted_time
FROM events
WHERE FROM_UNIXTIME(event_time) >= '2026-07-01';

SQLite

SELECT 
    id,
    event_time,
    datetime(event_time, 'unixepoch') AS readable_time,
    strftime('%Y-%m-%d %H:%M:%S', event_time, 'unixepoch') AS formatted_time
FROM events;

Formater les tableaux de sortie

# Create a nicely formatted table with column headers
convert() {
    printf "%-15s %-25s %-25s\n" "TIMESTAMP" "UTC" "LOCAL"
    printf "%-15s %-25s %-25s\n" "---------------" "-------------------------" "-------------------------"
    while read -r ts; do
        utc=$(TZ=UTC date -d @"$ts" "+%Y-%m-%d %H:%M:%S")
        local=$(date -d @"$ts" "+%Y-%m-%d %H:%M:%S")
        printf "%-15s %-25s %-25s\n" "$ts" "$utc" "$local"
    done <<< "$(cat "$1")"
}

Comparaison des performances

| Méthode | Idéale pour | Vitesse (10 000 horodatages) | Complexité | |--------|----------|----------------------|------------| | Convertisseur en ligne | Petits lots (< 50) | Instantané | Aucune | | Boucle bash | Petits à moyens (50-10K) | ~30 s | Faible | | xargs parallèle | Moyens (10K-100K) | ~10 s | Faible | | Python | Toute taille | ~2 s | Moyenne | | flux awk | Très grands (des millions) | ~5 s | Moyenne | | SQL | Données en base | Instantané | Faible |

Pour les lots quotidiens et rapides, utilisez notre Convertisseur d'horodatage Unix. Pour l'automatisation et les grands ensembles de données, scriptez la conversion en utilisant l'approche de programmation qui correspond à votre flux de travail.