Wie du einen Unix-Timestamp in Linux in ein Datum umwandelst: date, awk und Bash-Skripte

Als Entwickler oder Systemadministrator wirst du ständig Linux-Timestamps in lesbare Daten umwandeln müssen. Linux bietet dir mehrere saubere Wege, um das zu tun. Die schnellste Methode ist der date Befehl mit dem -d Flag, aber awk und Bash-Skripte ermöglichen es dir, Massen-Konvertierungen durchzuführen oder die Logik in Automatisierungen einzubetten. Hier erfährst du genau, wie jeder Ansatz funktioniert, mit Copy-Paste-Beispielen, die du sofort ausführen kannst.

Was ist ein Unix-Timestamp?

Ein Unix-Timestamp ist die Anzahl der Sekunden, die seit dem 1. Januar 1970 um 00:00:00 UTC vergangen sind. Dieser Startpunkt wird Unix-Epoch genannt. Der Timestamp 1700000000 bedeutet also, dass 1.700.000.000 Sekunden seit diesem Moment vergangen sind, was auf den 14. November 2023 um 22:13:20 UTC fällt.

Timestamps sind per Definition zeitzonen-neutral. Sie zählen immer von demselben UTC-Ursprung aus, was sie ideal für Logging, Datenbanken und APIs macht. Das menschenlesbare Datum, das du siehst, hängt vollständig davon ab, welche Zeitzone du während der Konvertierung anwendest. Wenn du ein tieferes Verständnis dafür brauchst, was Epoch-Zeit wirklich ist, behandelt der Artikel 1700000000 Epoch-Zeit: Die Grundlage von Unix-Timestamps das Konzept ausführlich.

Timestamp mit dem date-Befehl konvertieren

Der date Befehl ist das schnellste Tool für eine einmalige Konvertierung. Unter Linux (GNU coreutils) akzeptiert das -d Flag eine Zeichenkette wie @1700000000, wobei das @ Präfix dem date mitteilt, dass du einen Unix-Timestamp übergibst.

date -d @1700000000

Ausgabe:

Tue Nov 14 22:13:20 UTC 2023

Du kannst das Ausgabeformat mit date +FORMAT Syntax steuern. Die Format-Zeichenkette folgt den date +FORMAT Syntax. Die Format-Zeichenkette folgt GNU coreutils date Format-Spezifizierern. Häufige Formate:

• %Y-%m-%d gibt dir 2023-11-14
• %H:%M:%S gibt dir 22:13:20
• %A, %B %d %Y gibt dir Tuesday, November 14 2023
• %FT%T%z gibt dir das ISO-8601-Format: 2023-11-14T22:13:20+0000

Kombiniert sieht es so aus:

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

Ausgabe:

2023-11-14 22:13:20

Timestamps in Dateien mit awk konvertieren

Wenn du eine Protokolldatei oder CSV mit einer Spalte von Unix-Timestamps hast, ist awk das richtige Werkzeug. Es ermöglicht dir, jede Zeile zu verarbeiten und Timestamps im Handumdrehen zu konvertieren, ohne eine separate Skriptdatei zu erstellen.

Angenommen, du hast eine Protokolldatei, in der das erste Feld ein Unix-Timestamp ist:

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

Diese awk Einzeiler-Zeile konvertiert das erste Feld in ein lesbares Datum und gibt den Rest der Zeile aus:

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

Ausgabe:

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

Wenn du mit einer CSV arbeitest, in der der Timestamp in einer bestimmten Spalte ist (z.B. Spalte 3), passe die Feldverweisanpassung an:

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

awk hat auch eine eingebaute strftime Funktion in gawk (GNU awk), die das Spawning eines Subprozesses für jede Zeile vermeidet. Das ist auf großen Dateien erheblich schneller:

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

Bash-Skripte zur Timestamp-Konvertierung

Für wiederverwendbare Logik schlägt eine Bash-Funktion oder ein Skript das wiederholte Eingeben desselben Befehls. Hier ist eine einfache Funktion, die du zu deiner ~/.bashrc oder ~/.bash_profile hinzufügen kannst:

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

Nach dem Sourcing deines Profils ( source ~/.bashrc ), kannst du es so aufrufen:

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

Für ein eigenständiges Skript, das eine ganze Datei verarbeitet und die Ausgabe in eine neue Datei schreibt:

#!/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"

Mache es ausführbar und führe es aus:

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

Für weitere Muster zum Timestamp-Handling in Skripten und Anwendungen behandelt der Artikel Unix-Timestamp-Tutorial für Entwickler: Best Practices Grenzfälle und häufige Fehler, die es zu kennen lohnt.

Umgang mit Millisekunden-Timestamps

JavaScript, Java und viele APIs geben 13-stellige Millisekunden-Timestamps zurück (wie 1700000000000 ). Der date Befehl von Linux versteht nur Sekunden, daher musst du zuerst durch 1000 teilen.

Mit Bash-Arithmetik:

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

Oder als Einzeiler:

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

In gawk kannst du beide automatisch erkennen und verarbeiten:

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

Wenn du dir nicht sicher bist, ob ein bestimmter Timestamp in Sekunden oder Millisekunden vorliegt, erklärt der Leitfaden Sekunden vs. Millisekunden vs. Mikrosekunden: Welcher Unix-Timestamp sollte verwendet werden? die Unterschiede und wie du sie zuverlässig identifizierst.

Den aktuellen Unix-Timestamp in Linux abrufen

Der date +%s Befehl gibt den aktuellen Unix-Timestamp in Sekunden aus. Dies ist der Standard-Weg, um "gerade eben" als Epoch-Wert in Skripten zu erfassen.

date +%s
# Example output: 1700000000

Für Millisekunden multipliziere mit 1000 mit %3N (Nanosekunden auf Millisekunden gekürzt):

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

Du kannst auch den aktuellen Timestamp in einer Variablen speichern, um ihn in Skripten zu verwenden:

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

Zeitzonen-Handling bei Konvertierungen

Standardmäßig verwendet date die Zeitzone deines Systems (eingestellt in /etc/localtime oder über die TZ Umgebungsvariable). Um zu einer bestimmten Zeitzone zu konvertieren, ohne deine Systemeinstellungen zu ändern, stelle dem Befehl eine TZ Zuweisung voran:

# 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

Zeitzonen-Namen folgen dem Format der IANA-Zeitzonen-Datenbank (wie America/Chicago oder Europe/London ). Du kannst alle verfügbaren Zonen auf deinem System mit folgendem Befehl auflisten:

timedatectl list-timezones

In einem Bash-Skript, das mehrere Zeitzonen verarbeiten muss, setze und entferne TZ explizit, um Nebenwirkungen zu vermeiden:

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

Für einen gründlichen Blick auf die Interaktion zwischen UTC-Offsets und Zeitzonen-Konvertierungen mit Unix-Timestamps befasst sich der Artikel Unix-Timestamp UTC erklärt: Zeitzonen, Offsets und Konvertierungen ausführlich mit den Mechanismen.

Schnellreferenz-Tabelle

Überprüfe deinen Linux-Timestamp sofort

Füge jeden beliebigen Unix-Timestamp in unseren kostenlosen Konverter ein und erhalte das menschenlesbare Datum in Sekunden, Millisekunden, ISO 8601 und weiteren Formaten gleichzeitig. Keine Befehle erforderlich, erkennt deine Zeitzone automatisch und verarbeitet sowohl 10-stellige als auch 13-stellige Timestamps.

Überprüfe deinen Linux-Timestamp sofort →