UtilBoxx
Ferramentas de unidades·5 min

Como converter timestamps Unix para datas (e vice-versa)

Converta segundos da época Unix para datas legíveis em qualquer fuso horário. Com exemplos práticos.

O que é um timestamp Unix?

Um timestamp Unix (também chamado de tempo Unix, tempo POSIX ou tempo epoch) é o número de segundos que se passaram desde 00:00:00 UTC de 1 de janeiro de 1970, não contando segundos intercalares. Esse momento é chamado de epoch Unix.

Por exemplo:

  • 0 = 1970-01-01 00:00:00 UTC (a epoch)
  • 1.000.000.000 = 2001-09-09 01:46:40 UTC (o "bilênio")
  • 1.234.567.890 = 2009-02-13 23:31:30 UTC
  • 1.700.000.000 = 2023-11-14 22:13:20 UTC
  • 2.000.000.000 = 2033-05-18 03:33:20 UTC

Timestamps Unix estão em toda parte da computação:

  • Bancos de dados: PostgreSQL, MySQL e SQLite armazenam tempo internamente como timestamps Unix (ou com referência a eles).
  • Sistemas de arquivos: ext4, NTFS e APFS armazenam mtimes de arquivo como timestamps Unix.
  • APIs: APIs JSON comumente retornam timestamps como inteiros, ex.: `"created_at": 1700000000`.
  • Logs: A maioria dos sistemas de logging emite timestamps em formato Unix.
  • Linguagens de programação: PHP, Python, JavaScript, Go, Rust e Java têm suporte integrado.

A razão pela qual os timestamps Unix são populares: são inteiros simples, fáceis de comparar, fáceis de ordenar, independentes de fuso horário (sempre se referem a UTC) e triviais de armazenar. Também tornam a aritmética simples — para encontrar a duração de dois eventos, subtraia seus timestamps.

Como ler um timestamp Unix

O modelo mental: imagine um relógio que começou a tiquetaquear à meia-noite UTC de 1 de janeiro de 1970, e tem contado segundos desde então. O timestamp Unix é a leitura desse relógio.

``` 1 minuto = 60 segundos 1 hora = 3.600 segundos 1 dia = 86.400 segundos (24 × 60 × 60) 1 semana = 604.800 segundos (7 × 86.400) 1 ano ≈ 31.536.000 segundos (365,25 × 86.400, média) 1 década ≈ 315.360.000 segundos ```

Algumas âncoras mentais:

  • 1.000.000.000 = 2001-09-09. O bilênio Unix — o primeiro segundo com 10 dígitos.
  • 1.500.000.000 = 2017-07-14. A marca de "1,5 bilhão".
  • 2.000.000.000 = 2033-05-18. A primeira data de 2 bilhões de segundos.
  • O problema de 2038: Inteiros com sinal de 32 bits estouram em 2.147.483.647, que é 2038-01-19 03:14:07 UTC. Depois disso, timestamps Unix de 32 bits transbordam para valores negativos.

As fórmulas exatas de conversão

Timestamp para data humana

``` human_date = epoch + timestamp segundos (UTC) local_date = human_date convertida para fuso horário local ```

Na maioria das linguagens de programação:

```python import datetime ts = 1700000000 utc = datetime.datetime.fromtimestamp(ts, tz=datetime.timezone.utc) # 2023-11-14 22:13:20+00:00 local = datetime.datetime.fromtimestamp(ts) # depende do fuso horário do seu sistema ```

```js const ts = 1700000000; const date = new Date(ts * 1000); // JS usa milissegundos // 2023-11-14T22:13:20.000Z ```

Data humana para timestamp

``` timestamp = (date - epoch) em segundos ```

```python import datetime d = datetime.datetime(2023, 11, 14, 22, 13, 20, tzinfo=datetime.timezone.utc) ts = int(d.timestamp()) # 1700000000 ```

```js const d = new Date("2023-11-14T22:13:20Z"); const ts = Math.floor(d.getTime() / 1000); // 1700000000 ```

Fusos horários comuns (relativos a UTC)

Ao trabalhar com timestamps, você frequentemente precisa exibir em um fuso horário específico:

| Fuso horário | Abreviação | Offset | Cidades de exemplo | |--------------------------------------|------------|-----------------|------------------------------| | Tempo Universal Coordenado | UTC | 0 | Londres (inverno), Reykjavik| | Horário Padrão do Leste | EST | UTC−5 | Nova York (inverno) | | Horário de Verão do Leste | EDT | UTC−4 | Nova York (verão) | | Horário Padrão do Pacífico | PST | UTC−8 | Los Angeles (inverno) | | Horário de Verão do Pacífico | PDT | UTC−7 | Los Angeles (verão) | | Horário da Europa Central | CET | UTC+1 | Paris (inverno), Berlim | | Horário de Verão da Europa Central | CEST | UTC+2 | Paris (verão), Berlim | | Horário Padrão do Japão | JST | UTC+9 | Tóquio | | Horário Padrão da China | CST | UTC+8 | Pequim, Xangai | | Horário Padrão da Índia | IST | UTC+5:30 | Mumbai, Délhi | | Horário Padrão Leste da Austrália | AEST | UTC+10 | Sydney (inverno) | | Horário de Verão Leste da Austrália | AEDT | UTC+11 | Sydney (verão) |

Observe que alguns países (Índia, China) observam um único offset o ano todo, sem horário de verão.

Método 1: Use o conversor de tempo do UtilBoxx (Recomendado)

A maneira mais rápida, privada e precisa de converter timestamps Unix no navegador é o Conversor de Tempo do UtilBoxx. Suporta tanto segundos quanto milissegundos, exibe em qualquer fuso horário, e mostra a data ISO 8601 correspondente, UTC e hora local. Tudo roda no seu navegador: sem servidor, sem upload, sem registros.

Como usar:

  1. Acesse utilboxx.com/pt/tools/unit/time
  2. Digite um timestamp Unix (em segundos) ou uma string de data
  3. O valor convertido aparece instantaneamente
  4. Alterne entre fusos horários com um clique
  5. Copie o resultado

Por que recomendamos este método:

  • 100 % grátis, sem cadastro, sem e-mail, sem anúncios
  • Privacidade em primeiro lugar: nada sai do seu navegador
  • Bidirecional: timestamp ↔ data em qualquer direção
  • Multi-fuso horário: veja seu timestamp em UTC, seu fuso local, ou qualquer fuso
  • Lida com milissegundos para timestamps estilo JavaScript
  • Funciona em qualquer dispositivo com navegador

Se você trabalha com APIs, logs ou bancos de dados que armazenam tempo como timestamps Unix, esta ferramenta se paga na primeira semana.

Método 2: Python (módulo datetime)

O módulo `datetime` do Python é a ferramenta canônica para conversão de timestamps. As duas funções chave são `fromtimestamp()` e `timestamp()`.

```python import datetime from zoneinfo import ZoneInfo

# Converter timestamp para data (UTC) ts = 1700000000 utc_date = datetime.datetime.fromtimestamp(ts, tz=datetime.timezone.utc) # 2023-11-14 22:13:20+00:00

# Converter timestamp para data em um fuso horário específico ny_tz = ZoneInfo("America/New_York") ny_date = datetime.datetime.fromtimestamp(ts, tz=ny_tz) # 2023-11-14 17:13:20-05:00

# Converter data para timestamp d = datetime.datetime(2023, 11, 14, 22, 13, 20, tzinfo=datetime.timezone.utc) ts = int(d.timestamp()) # 1700000000

# Agora: timestamp atual now_ts = int(datetime.datetime.now(tz=datetime.timezone.utc).timestamp())

# Formatar data como ISO 8601 print(utc_date.isoformat()) # 2023-11-14T22:13:20+00:00 ```

Python 3.9+ também tem a forma mais simples `datetime.fromtimestamp(ts, tz=UTC)`, e o módulo `zoneinfo` (substituindo o antigo `pytz`) facilita o manuseio de fusos horários.

Método 3: Bash / linha de comando

O comando `date` no macOS e Linux pode tanto analisar quanto emitir timestamps Unix.

```bash # Converter um timestamp Unix para uma data legível (macOS / BSD) date -r 1700000000 # Tue Nov 14 22:13:20 UTC 2023

# Converter um timestamp Unix (Linux / GNU date) date -d @1700000000 # Tue Nov 14 22:13:20 UTC 2023

# Obter o timestamp Unix atual date +%s # 1700000000 (ou o que for agora)

# Converter uma string de data para timestamp Unix (GNU) date -d "2023-11-14 22:13:20 UTC" +%s # 1700000000

# Converter uma string de data para timestamp Unix (macOS) date -j -f "%Y-%m-%d %H:%M:%S" "2023-11-14 22:13:20" +%s # 1700000000

# Exibir em um fuso horário específico TZ="America/New_York" date -d @1700000000 # Tue Nov 14 17:13:20 EST 2023 ```

A sintaxe difere entre macOS e Linux. No macOS, `-r` lê um timestamp; no Linux, `-d @...` lê um timestamp e `-d "..."` analisa uma data. Para scripting, a forma GNU (Linux) é mais amigável; a forma macOS é mais trabalhosa mas funciona.

Método 4: JavaScript (no navegador ou Node.js)

JavaScript usa milissegundos para timestamps Unix, não segundos. Multiplique por 1.000 ao ir de segundos para milissegundos.

```js // Timestamp atual em milissegundos const now = Date.now(); // ex.: 1700000000000

// Converter segundos para milissegundos e criar um Date const ts = 1700000000; const date = new Date(ts * 1000); // 2023-11-14T22:13:20.000Z

// Exibir em um fuso horário específico usando Intl console.log(date.toLocaleString("en-US", { timeZone: "America/New_York" })); // 11/14/2023, 5:13:20 PM

// Exibir como ISO 8601 console.log(date.toISOString()); // 2023-11-14T22:13:20.000Z

// Converter data para timestamp (segundos) const d = new Date("2023-11-14T22:13:20Z"); const ts2 = Math.floor(d.getTime() / 1000); // 1700000000

// Analisar vários formatos new Date("2023-11-14"); // meia-noite UTC new Date("2023-11-14T22:13:20Z"); // 22:13:20 UTC new Date(1700000000 * 1000); // a partir de milissegundos new Date("Nov 14, 2023 22:13:20");// análise dependente de locale (evite!) ```

O objeto `Date` do JavaScript é famoso por ser peculiar. Para trabalho sério, use uma biblioteca como `date-fns`, `Luxon` ou `Day.js`. Para conversões rápidas, o `Date` integrado serve.

Perguntas frequentes

Por que a epoch Unix é 1 de janeiro de 1970?

É a data em que o sistema operacional Unix foi implementado pela primeira vez. Ken Thompson e Dennis Ritchie a escolheram arbitrariamente ao projetar o Unix nos Bell Labs em 1969-1970. Não há razão astronômica ou matemática; foi simplesmente o início da década em que estavam trabalhando. Vários outros sistemas escolheram epochs diferentes: Windows FILETIME usa 1 de janeiro de 1601; macOS HFS+ usou 1 de janeiro de 1904; GPS usa 6 de janeiro de 1980.

O que é o problema de 2038?

O problema de 2038 (também chamado Y2K38) é o overflow de inteiro com sinal de 32 bits que ocorre em 19 de janeiro de 2038 às 03:14:07 UTC. Um inteiro com sinal de 32 bits pode conter valores até 2.147.483.647. Um segundo depois, ele transborda para −2.147.483.648, que é interpretado como 1901-12-13 20:45:52 UTC. Qualquer sistema que ainda use timestamps Unix de 32 bits (principalmente dispositivos embarcados, bancos de dados antigos e alguns sistemas de arquivos) irá quebrar a menos que seja atualizado.

A solução é direta: mudar para inteiros de 64 bits, que estendem o alcance do timestamp Unix em 290 bilhões de anos. A maioria dos sistemas modernos já fez isso; o problema é principalmente com sistemas legados e embarcados.

Os timestamps Unix estão em segundos ou milissegundos?

Depende da linguagem:

  • Segundos: C, Python, Go, Rust, Java (tradicionalmente), shell, SQL
  • Milissegundos: JavaScript, Java (java.time.Instant), alguns bancos de dados

JavaScript é o grande caso atípico com milissegundos, o que causa bugs quando código JavaScript é misturado com código de outras linguagens. Sempre esclareça a unidade. O conversor do UtilBoxx lida com ambos com um único alternador.

Como os segundos intercalares afetam os timestamps Unix?

Estritamente falando, os timestamps Unix ignoram os segundos intercalares. Eles contam cada segundo como se houvesse exatamente 86.400 por dia. O UTC do mundo real tem segundos intercalares ocasionais (adicionados para manter o tempo atômico alinhado com a rotação da Terra), mas o tempo Unix não os inclui. Isso significa que o tempo Unix se desvia gradualmente do UTC em uma fração de segundo a cada poucos anos.

Na prática, isso raramente importa para código de aplicação. NTP (Network Time Protocol) lida com a discrepância. Se você precisa de TAI estrito ou tempo atômico, timestamps Unix não são a ferramenta certa.

O que é "ISO 8601"?

ISO 8601 é um padrão internacional para formatos de data e hora, projetado para ser inequívoco e legível por máquina. Exemplos:

  • `2023-11-14` (apenas data)
  • `2023-11-14T22:13:20` (data e hora, sem fuso horário)
  • `2023-11-14T22:13:20Z` (UTC, "Z" = "Zulu time")
  • `2023-11-14T22:13:20+05:00` (com offset de fuso horário)
  • `2023-11-14T22:13:20.123Z` (com milissegundos)
  • `20231114T221320Z` (forma compacta, sem separadores)

ISO 8601 é o formato recomendado para armazenar e trocar valores de data/hora porque ordena lexicograficamente e analisa sem ambiguidade. A maioria das APIs o utiliza.

Como obtenho o timestamp Unix atual?

Em todas as principais linguagens:

```bash # bash date +%s ```

```python import time time.time() # 1700000000.123 (float, com segundos fracionários) int(time.time()) # 1700000000 (segundos inteiros) ```

```js Date.now() / 1000 // 1700000000.123 Math.floor(Date.now() / 1000) // 1700000000 ```

Conclusão

Timestamps Unix são a linguagem universal do tempo na computação. São inteiros simples, fáceis de comparar, fáceis de armazenar, e independentes de fuso horário. A epoch é 1 de janeiro de 1970, e os timestamps contam segundos desde então.

Para conversões ocasionais, o Conversor de Tempo do UtilBoxx é privado, grátis e funciona offline uma vez carregado. Para trabalho em lote ou com scripts, o `datetime` do Python ou o comando `date` do bash lidam com qualquer volume de dados. Para trabalho interativo, o `Date` do JavaScript está embutido em todo navegador.

O atalho mental: 1.000.000.000 = 2001 (bilênio Unix), 1.500.000.000 = 2017, e 2.000.000.000 = 2033. Com estas âncoras, você pode estimar o ano de qualquer timestamp de 10 dígitos na sua cabeça. E lembre-se: em 12 anos chega o problema de 2038, então audite seus timestamps de 32 bits agora.

← Voltar para todos os artigos