Comment Convertir un Timestamp Unix en Date sous Linux : date, awk, et Scripts Bash

Convertir un timestamp Unix en date est une tâche que tu effectueras constamment en tant que développeur ou administrateur système, et Linux te propose plusieurs méthodes simples et efficaces. La plus rapide est la commande date avec le flag -d , mais awk et les scripts Bash te permettent de gérer des conversions en masse ou d'intégrer cette logique dans tes automatisations. Voici exactement comment fonctionne chaque approche, avec des exemples prêts à copier-coller que tu peux exécuter maintenant.

Qu'est-ce qu'un timestamp Unix ?

Un timestamp Unix est le nombre de secondes écoulées depuis le 1er janvier 1970 à 00:00:00 UTC. Ce point de départ s'appelle l'époque Unix. Donc le timestamp 1700000000 signifie que 1 700 000 000 secondes se sont écoulées depuis ce moment, ce qui correspond au 14 novembre 2023 à 22:13:20 UTC.

Les timestamps sont neutres par rapport au fuseau horaire, par définition. Ils comptent toujours à partir de la même origine UTC, ce qui les rend idéaux pour les journaux, les bases de données et les API. La date lisible que tu vois dépend entièrement du fuseau horaire que tu appliques lors de la conversion. Si tu veux mieux comprendre ce qu'est vraiment le temps d'époque, l'article Temps d'époque : Les fondations des timestamps Unix couvre le concept en détail.

Convertir un timestamp avec la commande date

La commande date est l'outil le plus rapide pour une conversion ponctuelle. Sous Linux (GNU coreutils), le flag -d accepte une chaîne comme @1700000000, où le préfixe @ indique à date que tu passes un timestamp Unix.

date -d @1700000000

Résultat :

Tue Nov 14 22:13:20 UTC 2023

Tu peux contrôler le format de sortie en utilisant la syntaxe date +FORMAT. La chaîne de format suit les spécificateurs de format GNU coreutils. Voici les plus courants :

• %Y-%m-%d te donne 2023-11-14
• %H:%M:%S te donne 22:13:20
• %A, %B %d %Y te donne Tuesday, November 14 2023
• %FT%T%z te donne le format ISO 8601 : 2023-11-14T22:13:20+0000

En les combinant :

date -d @1700000000 "+%Y-%m-%d %H:%M:%S"

Résultat :

2023-11-14 22:13:20

Convertir les timestamps dans les fichiers avec awk

Quand tu as un fichier journal ou CSV avec une colonne de timestamps Unix, awk est l'outil approprié. Il te permet de traiter chaque ligne et de convertir les timestamps à la volée sans fichier de script séparé.

Supposons que tu aies un fichier journal où le premier champ est un timestamp Unix :

1700000000 user=alice action=login
1700003600 user=bob action=logout

Cette commande awk d'une seule ligne convertit le premier champ en date lisible et affiche le reste de la ligne :

awk '{cmd="date -d @"$1" \"+%Y-%m-%d %H:%M:%S\""; cmd | getline d; close(cmd); $1=d; print}' logfile.txt

Résultat :

2023-11-14 22:13:20 user=alice action=login
2023-11-14 23:13:20 user=bob action=logout

Si tu travailles avec un CSV où le timestamp se trouve dans une colonne spécifique (disons la colonne 3), ajuste la référence du champ :

awk -F',' '{cmd="date -d @"$3" \"+%Y-%m-%d %H:%M:%S\""; cmd | getline d; close(cmd); $3=d; print}' OFS=',' data.csv

awk dispose également d'une fonction strftime intégrée dans gawk (GNU awk), ce qui évite de générer un sous-processus pour chaque ligne. C'est beaucoup plus rapide sur les fichiers volumineux :

gawk '{print strftime("%Y-%m-%d %H:%M:%S", $1), $2, $3}' logfile.txt

Scripts Bash pour la conversion de timestamps

Pour une logique réutilisable, une fonction Bash ou un script est bien mieux que de taper la même commande à répétition. Voici une fonction simple que tu peux ajouter à ton ~/.bashrc ou ~/.bash_profile :

ts2date() {
  date -d "@$1" "+%Y-%m-%d %H:%M:%S %Z"
}

Après avoir chargé ton profil ( source ~/.bashrc ), tu peux l'appeler comme ceci :

ts2date 1700000000
# Output: 2023-11-14 22:13:20 UTC

Pour un script autonome qui traite un fichier entier et écrit la sortie dans un nouveau fichier :

#!/bin/bash
# convert_timestamps.sh
# Usage: ./convert_timestamps.sh input.txt output.txt

INPUT="$1"
OUTPUT="$2"

while IFS= read -r line; do
  timestamp=$(echo "$line" | awk '{print $1}')
  rest=$(echo "$line" | cut -d' ' -f2-)
  readable=$(date -d "@$timestamp" "+%Y-%m-%d %H:%M:%S")
  echo "$readable $rest"
done < "$INPUT" > "$OUTPUT"

echo "Done. Results written to $OUTPUT"

Rends-le exécutable et lance-le :

chmod +x convert_timestamps.sh
./convert_timestamps.sh logfile.txt converted.txt

Pour plus de modèles autour de la gestion des timestamps dans les scripts et les applications, le Tutoriel Unix Timestamp pour développeurs : Meilleures pratiques couvre les cas limites et les erreurs courantes qu'il est bon de connaître.

Gérer les timestamps en millisecondes

JavaScript, Java et beaucoup d'API retournent des timestamps de 13 chiffres en millisecondes (comme 1700000000000 ). La commande date de Linux ne comprend que les secondes, donc tu dois d'abord diviser par 1000.

En utilisant l'arithmétique Bash :

MS_TIMESTAMP=1700000000000
SEC_TIMESTAMP=$((MS_TIMESTAMP / 1000))
date -d "@$SEC_TIMESTAMP" "+%Y-%m-%d %H:%M:%S"

Ou en une seule ligne :

date -d "@$((1700000000000 / 1000))" "+%Y-%m-%d %H:%M:%S"

Dans gawk, tu peux détecter et gérer les deux automatiquement :

gawk '{
  ts = $1
  if (length(ts) == 13) ts = int(ts / 1000)
  print strftime("%Y-%m-%d %H:%M:%S", ts), $2, $3
}' logfile.txt

Si tu n'es pas sûr qu'un timestamp spécifique soit en secondes ou en millisecondes, le guide Secondes vs Millisecondes vs Microsecondes : Quel timestamp Unix devrais-tu utiliser ? explique les différences et comment les identifier de manière fiable.

Obtenir le timestamp Unix actuel sous Linux

La commande date +%s affiche le timestamp Unix actuel en secondes. C'est la façon standard de capturer "maintenant" comme valeur d'époque dans les scripts.

date +%s
# Example output: 1700000000

Pour les millisecondes, multiplie par 1000 en utilisant %3N (nanosecondes tronquées aux millisecondes) :

date +%s%3N
# Example output: 1700000000000

Tu peux aussi stocker le timestamp actuel dans une variable pour l'utiliser dans les scripts :

NOW=$(date +%s)
echo "Script started at: $(date -d @$NOW "+%Y-%m-%d %H:%M:%S")"

Gestion des fuseaux horaires dans les conversions

Par défaut, date utilise le fuseau horaire local de ton système (défini dans /etc/localtime ou via la variable d'environnement TZ ). Pour convertir vers un fuseau horaire spécifique sans changer tes paramètres système, préfixe la commande avec une assignation TZ :

# Convert to New York time
TZ="America/New_York" date -d @1700000000 "+%Y-%m-%d %H:%M:%S %Z"
# Output: 2023-11-14 17:13:20 EST

# Convert to Tokyo time
TZ="Asia/Tokyo" date -d @1700000000 "+%Y-%m-%d %H:%M:%S %Z"
# Output: 2023-11-15 07:13:20 JST

Les noms de fuseaux horaires suivent le format de la Base de données des fuseaux horaires IANA (comme America/Chicago ou Europe/London ). Tu peux lister toutes les zones disponibles sur ton système avec :

timedatectl list-timezones

Dans un script Bash qui doit gérer plusieurs fuseaux horaires, définis et désactives TZ explicitement pour éviter les effets secondaires :

convert_with_tz() {
  local ts="$1"
  local tz="$2"
  TZ="$tz" date -d "@$ts" "+%Y-%m-%d %H:%M:%S %Z"
}

convert_with_tz 1700000000 "Europe/Berlin"
# Output: 2023-11-14 23:13:20 CET

Pour une étude approfondie de la façon dont les décalages UTC et les conversions de fuseaux horaires interagissent avec les timestamps Unix, l'article Unix Timestamp UTC expliqué : Fuseaux horaires, décalages et conversions approfondit les mécanismes.

Tableau de référence rapide

Vérifie ton timestamp Linux instantanément

Colle n'importe quel timestamp Unix dans notre convertisseur gratuit et obtiens la date lisible en secondes, millisecondes, ISO 8601 et bien d'autres formats simultanément. Aucune commande nécessaire, détecte automatiquement ton fuseau horaire, et gère les timestamps de 10 et 13 chiffres.

Vérifie ton timestamp Linux instantanément →