🕐
← Voltar aos guias

Trabalhando com Timestamps Unix em Linguagens de Programação

· Tags: javascript, python, php, golang, programming, unix-timestamp, epoch, database

Por que Timestamps Unix em Programação?

Timestamps Unix são a moeda universal do tempo no software. Eles tornam a aritmética de datas trivial (basta somar ou subtrair segundos), eliminam a confusão de fusos horários e serializam de forma limpa para JSON. Toda linguagem de programação fornece funções simples para trabalhar com eles, mas as APIs diferem sutilmente. Este guia cobre as linguagens mais comuns e suas melhores práticas.

JavaScript (Navegador e Node.js)

JavaScript usa milissegundos para seu objeto Date, enquanto a maioria dos outros sistemas usa segundos. Esta é a fonte mais comum de bugs.

Obtendo o Timestamp Atual

// Milliseconds since epoch (standard JavaScript)
const nowMs = Date.now();         // 1785292800000

// Seconds since epoch (for compatibility)
const nowSec = Math.floor(Date.now() / 1000);  // 1785292800

// Node.js high-resolution timer (microseconds)
const hrTime = process.hrtime.bigint();

Convertendo um Timestamp em uma Data

// From seconds (most APIs and databases)
const timestamp = 1785292800;
const date = new Date(timestamp * 1000);  // Multiply by 1000!

// From milliseconds (JavaScript native)
const dateFromMs = new Date(1785292800000);

// Format the result
console.log(date.toISOString());
// Output: 2026-07-19T00:00:00.000Z

console.log(date.toLocaleString("en-US", { timeZone: "America/New_York" }));
// Output: 7/18/2026, 8:00:00 PM

Analisando uma String de Data em um Timestamp

// Using Date.parse() (returns milliseconds)
const ms = Date.parse("2026-07-19T00:00:00Z");
const sec = ms / 1000;  // 1785292800

// Using Date constructor
const ts = Math.floor(new Date("2026-07-19 UTC").getTime() / 1000);

Aviso: o comportamento do Date.parse() varia entre navegadores para strings de data não padronizadas. Usar o formato ISO 8601 com um especificador de fuso horário (Z para UTC) é o mais seguro.

Trabalhando com Fusos Horários em JavaScript

// Format in a specific timezone
const date = new Date(1785292800 * 1000);
const options = {
  timeZone: "Asia/Tokyo",
  year: "numeric", month: "2-digit", day: "2-digit",
  hour: "2-digit", minute: "2-digit", second: "2-digit",
};
console.log(date.toLocaleString("ja-JP", options));
// Output: 07/19/2026 09:00:00

Para operações avançadas de fuso horário, a API Intl.DateTimeFormat ou bibliotecas como date-fns-tz e Luxon são recomendadas.

Python

Python fornece módulos de baixo nível (time) e de alto nível (datetime) para trabalhar com timestamps.

Obtendo o Timestamp Atual

import time

# Seconds as a float (including fractional milliseconds)
current = time.time()
# Example: 1785292800.123456

# As an integer
current_int = int(time.time())

Convertendo um Timestamp em um Datetime

from datetime import datetime

# UTC datetime (Python 3.x)
dt_utc = datetime.utcfromtimestamp(1785292800)

# Timezone-aware datetime (Python 3.9+ with zoneinfo)
from zoneinfo import ZoneInfo
dt_tokyo = datetime.fromtimestamp(1785292800, tz=ZoneInfo("Asia/Tokyo"))

# Formatted string
print(dt_utc.strftime("%Y-%m-%d %H:%M:%S"))
# Output: 2026-07-19 00:00:00

Analisando uma String de Data em um Timestamp

import time
from datetime import datetime

# From date string
dt = datetime.strptime("2026-07-19 00:00:00", "%Y-%m-%d %H:%M:%S")
timestamp = time.mktime(dt.timetuple())  # Treats as local time

# For UTC input
from datetime import timezone
timestamp_utc = dt.replace(tzinfo=timezone.utc).timestamp()

Trabalhando com Pandas (Análise de Dados)

import pandas as pd

# Convert a column of Unix timestamps to datetime
df["timestamp"] = pd.to_datetime(df["unix_seconds"], unit="s")

# Convert to different units
df["datetime_ms"] = pd.to_datetime(df["unix_milliseconds"], unit="ms")

# Set a timezone
df["timestamp_ny"] = df["timestamp"].dt.tz_localize("UTC").dt.tz_convert("America/New_York")

PHP

PHP tem a API mais simples para operações de timestamp.

Obtendo o Timestamp Atual

<?php
$now = time();           // Integer: 1785292800
$nowMicro = microtime();  // String: "0.12345600 1785292800"
$nowFloat = microtime(true);  // Float: 1785292800.1235

Convertendo um Timestamp em uma Data

<?php
echo date("Y-m-d H:i:s", 1785292800);
// Output: 2026-07-19 00:00:00

// With timezone
$tz = new DateTimeZone("Europe/London");
$dt = new DateTime("@1785292800");
$dt->setTimezone($tz);
echo $dt->format("Y-m-d H:i:s");

Go

O pacote time do Go é bem projetado, mas exige compreensão explícita dos tipos envolvidos.

Obtendo o Timestamp Atual

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    sec := now.Unix()            // int64 seconds
    milli := now.UnixMilli()     // int64 milliseconds
    nano := now.UnixNano()       // int64 nanoseconds
    fmt.Printf("Seconds: %d\n", sec)
}

Convertendo um Timestamp em uma Data

t := time.Unix(1785292800, 0)
fmt.Println(t.UTC())
// Output: 2026-07-19 00:00:00 +0000 UTC

// Format as string
fmt.Println(t.Format("2006-01-02 15:04:05"))
// Output: 2026-07-19 00:00:00

// With timezone
loc, _ := time.LoadLocation("America/Chicago")
fmt.Println(t.In(loc))

Rust

use std::time::{SystemTime, UNIX_EPOCH};

// Current timestamp
let now = SystemTime::now()
    .duration_since(UNIX_EPOCH)
    .expect("Time went backwards");
println!("Seconds: {}", now.as_secs());

// Timestamp to date
let dt = chrono::NaiveDateTime::from_timestamp_opt(1785292800, 0).unwrap();
println!("{}", dt.format("%Y-%m-%d %H:%M:%S"));

Armazenamento em Banco de Dados: Melhores Práticas

Escolhendo o Tipo de Coluna Certo

| Banco de Dados | Tipo Recomendado | Observações | |----------|-----------------|-------| | PostgreSQL | TIMESTAMP WITH TIME ZONE ou BIGINT | O tipo nativo de timestamp é preferido | | MySQL / MariaDB | INT UNSIGNED (para datas até 2106) ou BIGINT | Evite o tipo TIMESTAMP (o alcance termina em 2038) | | SQLite | INTEGER | SQLite não tem tipo nativo de timestamp | | MongoDB | objeto Date ou int64 | A data BSON é internamente um timestamp de 64 bits |

Exemplo com PostgreSQL

-- Store as native timestamp
CREATE TABLE events (
    id SERIAL PRIMARY KEY,
    occurred_at TIMESTAMP WITH TIME ZONE NOT NULL,
    payload JSONB
);

-- Insert with current time
INSERT INTO events (occurred_at) VALUES (NOW());

-- Query as Unix timestamp
SELECT EXTRACT(EPOCH FROM occurred_at) AS unix_ts FROM events;

Exemplo com MySQL

-- Using BIGINT for future-proof storage
CREATE TABLE logs (
    id INT AUTO_INCREMENT PRIMARY KEY,
    event_time BIGINT NOT NULL,
    message TEXT
);

-- Insert current timestamp
INSERT INTO logs (event_time, message) VALUES (UNIX_TIMESTAMP(), 'Server started');

-- Query and convert
SELECT FROM_UNIXTIME(event_time) AS readable_time FROM logs;

Tabela de Comparação de Linguagens

| Linguagem | Timestamp Atual | Timestamp para Data | Data para Timestamp | Resolução | |----------|-------------------|-------------------|-------------------|------------| | JavaScript | Date.now() | new Date(ts * 1000) | Date.parse(str) / 1000 | Milissegundos | | Python | time.time() | datetime.fromtimestamp(ts) | datetime.strptime(str).timestamp() | Segundos flutuantes | | PHP | time() | date("Y-m-d", ts) | strtotime(str) | Segundos | | Go | time.Now().Unix() | time.Unix(ts, 0) | time.Parse(layout, str).Unix() | Segundos | | Rust | SystemTime::now() | NaiveDateTime::from_timestamp_opt() | — | Várias |

Qualquer que seja a linguagem usada, nosso Conversor de Timestamp Unix é um companheiro confiável para verificações rápidas e depuração.