Hoe converteer je meerdere Unix-tijdstempels tegelijk

Waarom tijdstempels in batches converteren?

Wanneer je werkt met serverlogs, database-exportbestanden, API-reacties of analyse-datasets, kom je zelden één tijdstempel tegelijk tegen. Realistische gegevens bevatten vaak duizenden of miljoenen Unix-tijdstempels verspreid over bestanden, kolommen of JSON-payloads. Elk ervan handmatig converteren is onpraktisch. Batchverwerking verandert bergen ruwe getallen in leesbare tijdlijnen.

Deze gids behandelt praktische benaderingen voor het converteren van meerdere tijdstempels met behulp van opdrachtregeltools, scripts en onze online tool.

Methode 1: De online batchconverter gebruiken

Onze Unix-tijdstempelconverter ondersteunt batchinvoer. Plak meerdere tijdstempels (één per regel of door komma's gescheiden) en de tool converteert ze allemaal tegelijk, waarbij de resultaten in een tabel worden weergegeven die op tijdzone is gesorteerd.

Dit is ideaal voor gematigde batches — tientallen tot honderden tijdstempels — waar je een snel, visueel resultaat nodig hebt zonder code te schrijven.

Methode 2: Batchverwerking op de opdrachtregel

Basislus met de date-opdracht

# 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

Lezen uit een bestand

# 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 gebruiken voor parallelle verwerking

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

Uitvoeren naar een CSV-bestand

# 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: Tijdstempels uit logbestanden extraheren

Logbestanden bevatten vaak tijdstempels ingebed in gestructureerde of semi-gestructureerde tekst. Hier zijn praktische technieken voor veelvoorkomende logformaten.

Apache / Nginx-toegangslogs

Apache- en Nginx-logs gebruiken vaak het formaat %{%Y-%m-%d}T of, indien geconfigureerd, Unix-tijdstempels:

# 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 toepassingen loggen vaak in JSON-formaat:

# 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

Aangepaste gescheiden 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 gebruiken voor geavanceerde batchverwerking

Python is de meest flexibele tool voor batchconversie, vooral wanneer tijdstempels filtering, transformatie of export nodig hebben.

Een lijst tijdstempels converteren

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

Een CSV-bestand verwerken

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

Filteren op datumbereik

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 gebruiken voor streamingconversie

Voor zeer grote bestanden (miljoenen rijen) verwerkt awk gegevens als een stream zonder alles in het geheugen te 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
}

Gebruik:

./batch-convert.awk server.log

Methode 6: SQL gebruiken voor databasetijdstempels

Als je tijdstempels in een database staan, laat SQL het werk dan doen:

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;

Uitvoertabellen opmaken

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

Prestatievergelijking

| Methode | Het beste voor | Snelheid (10K tijdstempels) | Complexiteit | |--------|----------|----------------------|------------| | Online converter | Kleine batches (< 50) | Onmiddellijk | Geen | | Bash-lus | Klein-medium (50-10K) | ~30s | Laag | | xargs parallel | Medium (10K-100K) | ~10s | Laag | | Python | Elke omvang | ~2s | Medium | | awk-stream | Zeer groot (miljoenen) | ~5s | Medium | | SQL | Databasegegevens | Onmiddellijk | Laag |

Gebruik voor snelle, alledaagse batches onze Unix-tijdstempelconverter. Voor automatisering en grote datasets script je de conversie met de programmeerbenadering die bij je workflow past.