Mehrere Unix-Zeitstempel auf einmal konvertieren

Warum Zeitstempel in Batches konvertieren?

Wenn Sie mit Server-Logs, Datenbankexporten, API-Antworten oder Analysedatensätzen arbeiten, stoßen Sie selten auf einen einzelnen Zeitstempel. Reale Daten enthalten oft Tausende oder Millionen von Unix-Zeitstempeln, verteilt über Dateien, Spalten oder JSON-Payloads. Jeden einzelnen manuell zu konvertieren, ist unpraktisch. Batch-Verarbeitung verwandelt Berge von rohen Zahlen in lesbare Zeitlinien.

Dieser Leitfaden behandelt praktische Ansätze zum Konvertieren mehrerer Zeitstempel mithilfe von Kommandozeilenwerkzeugen, Skripten und unserem Online-Tool.

Methode 1: Verwendung des Online-Batch-Konverters

Unser Unix-Zeitstempel-Konverter unterstützt Batch-Eingabe. Fügen Sie mehrere Zeitstempel ein (einer pro Zeile oder durch Kommas getrennt), und das Tool konvertiert alle auf einmal und zeigt die Ergebnisse in einer nach Zeitzone sortierten Tabelle an.

Dies ist ideal für mittelgroße Batches — von Dutzenden bis Hunderten von Zeitstempeln —, bei denen Sie ein schnelles, visuelles Ergebnis benötigen, ohne Code zu schreiben.

Methode 2: Batch-Verarbeitung über die Kommandozeile

Grundlegende Schleife mit dem date-Befehl

# 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

Aus einer Datei lesen

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

xargs für die Parallelverarbeitung verwenden

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

Ausgabe in eine CSV-Datei

# 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

Methode 3: Zeitstempel aus Logdateien extrahieren

Logdateien enthalten oft Zeitstempel, die in strukturiertem oder halbstrukturiertem Text eingebettet sind. Hier sind praktische Techniken für gängige Logformate.

Apache-/Nginx-Zugriffsprotokolle

Apache- und Nginx-Logs verwenden oft das Format %{%Y-%m-%d}T oder, falls konfiguriert, Unix-Zeitstempel:

# 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

JSON-Logs

Moderne Anwendungen protokollieren oft im JSON-Format:

# 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

Benutzerdefinierte, getrennte Logs

# 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

Methode 4: Python für erweiterte Batch-Verarbeitung verwenden

Python ist das flexibelste Werkzeug für die Batch-Konvertierung, insbesondere wenn Zeitstempel gefiltert, transformiert oder exportiert werden müssen.

Konvertieren einer Liste von Zeitstempeln

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))

Eine CSV-Datei verarbeiten

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")

Nach Datumsbereich filtern

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')}")

Methode 5: awk für die Streaming-Konvertierung verwenden

Für sehr große Dateien (Millionen von Zeilen) verarbeitet awk Daten als Stream, ohne alles in den Speicher zu laden:

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

Verwendung:

./batch-convert.awk server.log

Methode 6: SQL für Datenbank-Zeitstempel verwenden

Wenn sich Ihre Zeitstempel in einer Datenbank befinden, lassen Sie SQL die Arbeit erledigen:

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;

Ausgabetabellen formatieren

# 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")"
}

Leistungsvergleich

| Methode | Am besten geeignet für | Geschwindigkeit (10K Zeitstempel) | Komplexität | |--------|----------|----------------------|------------| | Online-Konverter | Kleine Batches (< 50) | Sofort | Keine | | Bash-Schleife | Klein-mittel (50-10K) | ~30s | Gering | | xargs parallel | Mittel (10K-100K) | ~10s | Gering | | Python | Beliebige Größe | ~2s | Mittel | | awk-Stream | Sehr groß (Millionen) | ~5s | Mittel | | SQL | Datenbankdaten | Sofort | Gering |

Für schnelle, alltägliche Batches verwenden Sie unseren Unix-Zeitstempel-Konverter. Für Automatisierung und große Datensätze skripten Sie die Konvertierung mit dem Programmieransatz, der zu Ihrem Arbeitsablauf passt.