Formatos de timestamp Unix explicados

Todos os formatos de timestamp Unix num relance

Um timestamp Unix é apenas um número, e o seu formato é na verdade apenas a sua unidade — com que finura conta desde 1 de janeiro de 1970 UTC. A unidade quase sempre se lê pelo número de dígitos: 10 dígitos são segundos, 13 são milissegundos, 16 são microssegundos, 19 são nanossegundos. Os dois formatos de cadeia, ISO 8601 e RFC 2822, são em vez disso autodescritivos. A tabela abaixo é todo o panorama; as secções seguintes cobrem cada formato e como distingui-los.

O tempo Unix em segundos — o formato universal

O formato mais comum: um inteiro de 32 ou 64 bits que conta o número de segundos inteiros desde 1 de janeiro de 1970 00:00:00 UTC. Atualmente um número de 10 dígitos à volta de 1,7 mil milhões.

• Exemplo: 1700000000 = 2023-11-15 06:13:20 UTC
• Usado por: Python time.time(), PHP time(), Go time.Now().Unix(), Ruby Time.now.to_i, C time(NULL)
• Armazenado como: int de 32 bits (legado, ano máx. 2038), int de 64 bits (moderno, seguro por milhares de milhões de anos)
• Base de dados: MySQL UNIX_TIMESTAMP(), PostgreSQL EXTRACT(EPOCH FROM NOW())::BIGINT

• The Open Group — Seconds Since the Epoch (POSIX)

O tempo Unix em milissegundos — o formato do JavaScript

Milissegundos desde o epoch Unix: um inteiro de 13 dígitos que fornece precisão de milissegundos. É o formato que o objeto Date do JavaScript usa internamente.

• Exemplo: 1700000000000 = 2023-11-15 06:13:20.000 UTC
• Usado por: JavaScript Date.now(), Java System.currentTimeMillis(), .NET DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
• Converter para segundos: Math.floor(ms / 1000)
• Converter a partir de segundos: seconds * 1000

• MDN — Date.now() e o objeto Date
• Milissegundos vs segundos — quando usar qual

ISO 8601 — o padrão legível por humanos

O ISO 8601 é um padrão internacional para representar datas e horas como cadeias. Ao contrário dos timestamps Unix, é autodescritivo: o formato codifica tanto a data/hora como o deslocamento de fuso.

• 2023-11-15T06:13:20Z — UTC (o sufixo Z significa UTC)
• 2023-11-15T01:13:20-05:00 — com deslocamento UTC explícito (EST)
• 2023-11-15T06:13:20.000Z — com milissegundos
• JavaScript: date.toISOString() devolve sempre UTC com sufixo Z
• Python: datetime.isoformat(), Go: time.Format(time.RFC3339)

• ISO 8601 e RFC 3339 — o guia completo do formato

RFC 2822 — formato de data de e-mail e HTTP

O RFC 2822 (atualizado pelo RFC 5322 para o e-mail, e espelhado pelo RFC 9110 para HTTP) é o formato de data legível usado nos cabeçalhos de e-mail e nas respostas HTTP. O Date.toUTCString() do JavaScript devolve este formato.

• Exemplo: Wed, 15 Nov 2023 06:13:20 GMT
• Usado em: cabeçalhos de resposta HTTP (Last-Modified, Date, Expires), cabeçalhos de e-mail (Date:)
• JavaScript: date.toUTCString()
• Menos comum nas API modernas mas ainda muito encontrado na infraestrutura web

• RFC 5322 — Internet Message Format (o cabeçalho de data)

Como detetar o formato do timestamp

Quando recebes um valor de timestamp desconhecido, estas regras identificam o seu formato. O número de dígitos resolve cada caso numérico; os dois formatos de cadeia são óbvios à vista.

• Verificação de bom senso: qualquer valor numérico deve descodificar numa data credível da era atual (cerca de 2001–2038 para segundos de 10 dígitos)
• Uma data perto de 1970 ou a milhares de anos significa que a unidade foi lida errada

Microssegundos e nanossegundos

Alguns sistemas de alta precisão usam unidades menores que o milissegundo. São raras no código de aplicação mas aparecem em sistemas de baixo nível, internos de bases de dados e ferramentas de observabilidade.

• Microssegundos (µs): inteiro de 16 dígitos — Rust SystemTime as_micros(), PostgreSQL clock_gettime()
• Nanossegundos (ns): inteiro de 19 dígitos — Go time.Now().UnixNano(), Rust SystemTime as_nanos()
• PostgreSQL EXTRACT(EPOCH) devolve um número de vírgula flutuante com os microssegundos como parte fracionária
• Converter nanossegundos para segundos: dividir por 1.000.000.000 (1e9)

Resolução e precisão de frações de segundo

Cada formato acima traz uma resolução temporal diferente. Escolher um formato é escolher com que finura consegues distinguir dois momentos — de um segundo até um nanossegundo.

• Resolução de 1 segundo: segundos Unix (10 dígitos), POSIX time_t tradicional
• 1 milissegundo: JavaScript Date, MongoDB BSON Date, Java Instant.toEpochMilli()
• 1 microssegundo: timestamps Chrome/WebKit, Python datetime.timestamp(), PostgreSQL timestamp precision 6
• 100 nanossegundos: Windows FILETIME, .NET DateTime.Ticks
• 1 nanossegundo: Java Instant (precisão completa), Go time.UnixNano(), JS Temporal.Instant.epochNanoseconds (BigInt)
• Picossegundo e abaixo: formato de fio PTP/IEEE 1588 (1/2^32 de segundo), campo de fração do NTP
• Escolhe a resolução mais grosseira que satisfaça as tuas necessidades — a precisão de subsegundo perde-se muitas vezes na serialização JSON ou no round-trip de cadeia
• Ao converter entre formatos, passa por milissegundos ou nanossegundos Unix (via BigInt) — é o mínimo denominador comum que preserva a precisão

Conversores de formato de timestamp

Converte entre o tempo Unix e os formatos de timestamp específicos de plataforma que encontras na prática:

• Conversor FILETIME
• Conversor de Ticks .NET
• Tempo WebKit/Chrome
• Mac Absolute Time
• Timestamp Core Data
• Conversor de data Excel
• Timestamp NTP
• Conversor de tempo GPS
• Conversor de dia juliano