Como Converter Vários Timestamps Unix de Uma Vez

Por que Converter Timestamps em Lote?

Quando você trabalha com logs de servidor, exportações de banco de dados, respostas de API ou conjuntos de dados analíticos, raramente encontra um único timestamp por vez. Dados do mundo real frequentemente contêm milhares ou milhões de timestamps Unix espalhados por arquivos, colunas ou payloads JSON. Converter cada um manualmente é impraticável. O processamento em lote transforma montanhas de números brutos em linhas do tempo legíveis.

Este guia aborda abordagens práticas para converter vários timestamps usando ferramentas de linha de comando, scripts e nossa ferramenta online.

Método 1: Usando o Conversor Online em Lote

Nosso Conversor de Timestamp Unix suporta entrada em lote. Cole vários timestamps (um por linha ou separados por vírgula) e a ferramenta converte todos de uma vez, exibindo os resultados em uma tabela ordenada por fuso horário.

Isso é ideal para lotes de tamanho moderado — dezenas a centenas de timestamps — onde você precisa de um resultado rápido e visual sem escrever código.

Método 2: Processamento em Lote pela Linha de Comando

Loop Básico com o 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

Lendo de um Arquivo

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

Usando xargs para Processamento Paralelo

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

Saída para um Arquivo 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: Extraindo Timestamps de Arquivos de Log

Arquivos de log frequentemente contêm timestamps embutidos em texto estruturado ou semiestruturado. Aqui estão técnicas práticas para formatos de log comuns.

Logs de Acesso do Apache / Nginx

Logs do Apache e Nginx frequentemente usam o formato %{%Y-%m-%d}T ou, se configurados, timestamps 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

Logs JSON

Aplicações modernas frequentemente registram logs em 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

Logs com 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: Usando Python para Processamento em Lote Avançado

Python é a ferramenta mais flexível para conversão em lote, especialmente quando timestamps precisam de filtragem, transformação ou exportação.

Converter uma Lista de Timestamps

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

Processar um Arquivo 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 Intervalo de Datas

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: Usando awk para Conversão em Fluxo

Para arquivos muito grandes (milhões de linhas), o awk processa dados como um fluxo sem carregar tudo na memória:

#!/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: Usando SQL para Timestamps de Banco de Dados

Se seus timestamps estão em um banco de dados, deixe o SQL fazer o trabalho:

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;

Formatando Tabelas de Saída

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

Comparação de Desempenho

| Método | Melhor Para | Velocidade (10K timestamps) | Complexidade | |--------|----------|----------------------|------------| | Conversor online | Lotes pequenos (< 50) | Instantâneo | Nenhuma | | Loop Bash | Pequenos-médios (50-10K) | ~30s | Baixa | | xargs paralelo | Médios (10K-100K) | ~10s | Baixa | | Python | Qualquer tamanho | ~2s | Média | | Fluxo awk | Muito grandes (milhões) | ~5s | Média | | SQL | Dados de banco de dados | Instantâneo | Baixa |

Para lotes rápidos do dia a dia, use nosso Conversor de Timestamp Unix. Para automação e grandes conjuntos de dados, crie scripts de conversão usando a abordagem de programação que combina com seu fluxo de trabalho.