Entenda os timestamps Unix e o tempo Epoch
Entenda a época Unix, unidades, UTC, precisão inteira, limites de 2038 e 2106 e segundos intercalares com exemplos de código.
Um timestamp posiciona um evento em uma escala temporal. Para trocar um valor, combine época, unidade e tipo de relógio. Um contador desde a inicialização não representa uma data UTC. O Conversor Unix Timestamp / Epoch permite conferir valores e fusos sem enviar os cálculos a um servidor.
Época Unix: por que 1º de janeiro de 1970?
A origem é 1970-01-01 00:00:00 UTC, uma convenção histórica do Unix sem significado físico especial. Outra época mudaria o número, não o evento. NTP usa uma origem em 1900; GPS e contadores de fabricantes seguem outras referências. O número isolado não identifica sua época.
Contagem, valores positivos e negativos
Na aritmética de calendário POSIX usual, um dia UTC nominal tem 86400 segundos. Assim, 1970-01-02 à meia-noite UTC vale 86400. Isso não significa que todo dia local dure 24 horas. Valores positivos vêm após a época; −1 é o último segundo de 1969. O timestamp numérico independe do fuso.
Segundos até nanossegundos
| Unidade do timestamp | 1 s | 1700000000 s |
|---|---|---|
| Segundos (s) | 1 | 1700000000 |
| Milissegundos (ms) | 1000 | 1700000000000 |
| Microssegundos (µs) | 1000000 | 1700000000000000 |
| Nanossegundos (ns) | 1000000000 | 1700000000000000000 |
Multiplique segundos por 1000 para obter milissegundos e por um bilhão para nanossegundos. Acrescentar zeros não melhora a exatidão da fonte. JavaScript Date recebe milissegundos; muitas interfaces C recebem segundos. Coloque a unidade no nome do campo e no contrato de dados.
UTC, deslocamentos e identificadores IANA
2023-11-14 22:13:20 UTC e 23:13:20 em Paris são o mesmo instante. +01:00 fornece um deslocamento pontual; Europe/Paris inclui regras civis e transições. Abreviações como CST são ambíguas entre regiões.
Horas inexistentes e repetidas
Em Paris, 2024-03-31 02:30 não existe. Já 2024-10-27 02:30 ocorre duas vezes: 00:30 UTC e 01:30 UTC. O conversor rejeita lacunas e permite escolher a primeira ou segunda ocorrência. O dia do ano vem dos campos do calendário local, sem dividir uma duração local por 24 horas. As regras dependem dos dados IANA do navegador e podem mudar por decisões políticas.
Cálculo detalhado e valores representativos
1700000000 s × 1000 = 1700000000000 ms, ambos 2023-11-14T22:13:20Z. Adicionar 123456789 ns produz 1700000000123456789 ns, com fração .123456789. Date exibe .123; o conversor mantém separadamente os 456789 ns restantes.
| Segundos Unix | ISO 8601 (UTC) |
|---|---|
| -1 | 1969-12-31T23:59:59Z |
| 0 | 1970-01-01T00:00:00Z |
| 1000000000 | 2001-09-09T01:46:40Z |
| 1700000000 | 2023-11-14T22:13:20Z |
| 2147483647 | 2038-01-19T03:14:07Z |
| 4294967295 | 2106-02-07T06:28:15Z |
−1 ns representa 1969-12-31T23:59:59.999999999Z. O milissegundo que contém esse instante é −1 ms. Truncar a divisão em direção a zero mostraria incorretamente a época. Arredonde o quociente para menos infinito e preserve o resto.
O problema de 2038 e inteiros de 32 bits com sinal
A faixa é −2³¹ a 2³¹−1. O último segundo positivo, 2147483647, corresponde a 2038-01-19T03:14:07Z. O próximo não cabe. Em C, o estouro com sinal tem comportamento indefinido; não dependa de um aparente retorno a 1901. Amplie os operandos antes do cálculo e revise campos de arquivos e protocolos.
Contadores sem sinal e 2106
A faixa 0–4294967295 termina em 2106-02-07T06:28:15Z e não representa diretamente datas anteriores a 1970. Trocar para unsigned desloca o limite e altera a semântica dos negativos; não substitui uma migração duradoura do formato.
Faixa de 64 bits e precisão
Segundos inteiros com sinal de 64 bits abrangem cerca de 292 bilhões de anos em cada direção; nanossegundos da mesma largura, cerca de 292 anos, até 2262 no lado positivo. Bibliotecas de calendário podem ter limites menores. Binary64 representa todos os inteiros apenas até 2⁵³−1. Nanossegundos atuais exigem BigInt ou strings decimais em JavaScript. Um float de 32 bits não tem a precisão de um inteiro de 32 bits.
Segundos intercalares e limites POSIX
POSIX não conta cada segundo SI realmente transcorrido desde 1970 nem atribui um timestamp comum exclusivo ao segundo UTC :60. Sistemas podem saltar, repetir ou suavizar a correção. Não converta para TAI ou GPS com um deslocamento supostamente eterno. Subtrair relógios civis não garante uma duração física durante ajustes.
JavaScript / TypeScript
const timestampNs = BigInt("1700000000123456789");
const divisor = BigInt(1_000_000);
const q = timestampNs / divisor;
const ms = timestampNs < 0 && timestampNs % divisor !== BigInt(0)
? q - BigInt(1) : q;
if (ms < BigInt("-8640000000000000") || ms > BigInt("8640000000000000")) {
throw new RangeError("Date");
}
const iso = new Date(Number(ms)).toISOString();
console.log(iso);
console.log(timestampNs.toString());
Date exibe 2023-11-14T22:13:20.123Z; o inteiro original mantém toda a fração. O conversor valida o valor completo antes de construir Date e recompõe ISO e RFC 3339 separadamente. RFC 3339 usa anos de quatro dígitos; fora de 0000–9999 a saída fica indisponível. RFC 2822 mostra segundos inteiros e exige ano a partir de 1900.
Python sem passagem por ponto flutuante
from datetime import datetime, timezone, timedelta
epoch = datetime(1970, 1, 1, tzinfo=timezone.utc)
instant = datetime(2023, 11, 14, 22, 13, 20, 123456, tzinfo=timezone.utc)
delta = instant - epoch
timestamp_us = ((delta.days * 86400 + delta.seconds) * 1_000_000
+ delta.microseconds)
restored = epoch + timedelta(microseconds=timestamp_us)
assert restored == instant
print(timestamp_us, restored.isoformat())
UTC explícito evita depender do fuso da máquina. timedelta preserva microssegundos inteiros; timestamp() devolve um float que pode arredondar frações. datetime não armazena nanossegundos. Use zoneinfo para IANA e defina uma política para horas repetidas.
C e armazenamento embarcado
#include <stdint.h>
#include <inttypes.h>
#include <stdio.h>
int main(void) {
int64_t seconds = INT64_C(1700000000);
int64_t milliseconds = seconds * INT64_C(1000);
int64_t after_2038 = (int64_t)INT32_MAX + INT64_C(1);
printf("%" PRId64 " %" PRId64 "\n", milliseconds, after_2038);
return 0;
}
Os produtos apresentados cabem em int64_t; código genérico precisa testar os limites antes da multiplicação. Uma CPU de 64 bits não garante time_t de 64 bits. A serialização direta desse tipo depende de ABI, largura e ordem de bytes. Especifique época, unidade, sinal e largura no protocolo. Consulte Timestamps Unix em sistemas embarcados, APIs e bancos de dados.
Erros comuns
- Passar segundos para Date ou adivinhar a unidade pela quantidade de dígitos.
- Converter uma string longa para Number antes de BigInt, perdendo dígitos irrecuperáveis.
- Aplicar duas vezes o deslocamento do fuso.
- Aceitar 31 de fevereiro por normalização automática.
- Confundir resolução de exibição com exatidão do relógio.
Perguntas técnicas
Trocar o fuso altera o timestamp?
Só altera a representação de calendário. Interpretar novos campos locais exige uma zona.
Valores negativos podem conter frações?
Sim. −0.5 s é meio segundo antes da época. Preserve o sinal e o resto nas conversões.
O relógio atual consulta uma referência de rede?
Ele lê o relógio do dispositivo sem consultar NTP. A sincronização do sistema determina sua exatidão.
Ferramentas e fontes
Conversor Unix Timestamp / Epoch · Timestamps Unix em sistemas embarcados, APIs e bancos de dados · Tolerância de frequência · PPM ↔ Hz.