Cómo convertir varias marcas de tiempo Unix a la vez

¿Por qué convertir marcas de tiempo por lotes?

Cuando trabajas con registros de servidor, exportaciones de bases de datos, respuestas de API o conjuntos de datos de analítica, rara vez encuentras una sola marca de tiempo a la vez. Los datos del mundo real a menudo contienen miles o millones de marcas de tiempo Unix repartidas entre archivos, columnas o cargas útiles JSON. Convertir cada una manualmente es poco práctico. El procesamiento por lotes transforma montañas de números crudos en líneas de tiempo legibles.

Esta guía cubre enfoques prácticos para convertir múltiples marcas de tiempo usando herramientas de línea de comandos, scripts y nuestra herramienta en línea.

Método 1: Usar el convertidor de lotes en línea

Nuestro Convertidor de marcas de tiempo Unix admite entrada por lotes. Pega varias marcas de tiempo (una por línea o separadas por comas) y la herramienta las convierte todas a la vez, mostrando los resultados en una tabla ordenada por zona horaria.

Esto es ideal para lotes de tamaño moderado — de decenas a cientos de marcas de tiempo — donde necesitas un resultado rápido y visual sin escribir código.

Método 2: Procesamiento por lotes con línea de comandos

Bucle básico con el comando 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

Leer desde un archivo

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

Usar xargs para procesamiento paralelo

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

Salida a un archivo 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étodo 3: Extraer marcas de tiempo de archivos de registro

Los archivos de registro a menudo contienen marcas de tiempo incrustadas en texto estructurado o semiestructurado. Aquí tienes técnicas prácticas para formatos de registro comunes.

Registros de acceso de Apache / Nginx

Los registros de Apache y Nginx a menudo usan el formato %{%Y-%m-%d}T o, si se configuran, marcas de tiempo 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

Registros JSON

Las aplicaciones modernas a menudo registran en formato 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

Registros con delimitadores personalizados

# 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étodo 4: Usar Python para procesamiento por lotes avanzado

Python es la herramienta más flexible para la conversión por lotes, especialmente cuando las marcas de tiempo necesitan filtrado, transformación o exportación.

Convertir una lista de marcas de tiempo

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

Procesar un archivo 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")

Filtrar por rango de fechas

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étodo 5: Usar awk para conversión en streaming

Para archivos muy grandes (millones de filas), awk procesa los datos como un flujo sin cargar todo en memoria:

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

Uso:

./batch-convert.awk server.log

Método 6: Usar SQL para marcas de tiempo en bases de datos

Si tus marcas de tiempo están en una base de datos, deja que SQL haga el trabajo:

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;

Formatear tablas de salida

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

Comparación de rendimiento

| Método | Mejor para | Velocidad (10 mil marcas de tiempo) | Complejidad | |--------|----------|----------------------|------------| | Convertidor en línea | Lotes pequeños (< 50) | Instantánea | Ninguna | | Bucle de bash | Pequeño-medio (50-10 mil) | ~30 s | Baja | | xargs paralelo | Medio (10 mil-100 mil) | ~10 s | Baja | | Python | Cualquier tamaño | ~2 s | Media | | Flujo de awk | Muy grande (millones) | ~5 s | Media | | SQL | Datos de bases de datos | Instantánea | Baja |

Para lotes cotidianos y rápidos, usa nuestro Convertidor de marcas de tiempo Unix. Para automatización y conjuntos de datos grandes, automatiza la conversión usando el enfoque de programación que se adapte a tu flujo de trabajo.