O que são os milissegundos epoch
Os milissegundos epoch contam os milissegundos desde 1 de janeiro de 1970 às 00:00:00 UTC. Usam o mesmo epoch Unix dos segundos Unix, mas com três dígitos a mais de precisão. Um valor moderno de milissegundos epoch geralmente tem 13 dígitos, como 1700000000000.
Como converter millis em data
Se o valor já estiver em milissegundos, o JavaScript Date pode lê-lo diretamente. Se a ferramenta receptora espera segundos, divida primeiro por 1000. O erro principal é multiplicar ou dividir no limite errado.
- JavaScript: new Date(1700000000000).toISOString()
- Milliseconds to seconds: Math.floor(1700000000000 / 1000)
- Seconds to milliseconds: 1700000000 * 1000
- Java Instant: Instant.ofEpochMilli(1700000000000L)
- Python: datetime.fromtimestamp(ms / 1000, tz=timezone.utc)
Long para data em Java e bancos de dados
Buscas por «long para data» costumam vir de Java, Kotlin, Android ou exports de banco onde um timestamp é guardado como inteiro de 64 bits. O valor pode ser milissegundos epoch, mas também segundos, microssegundos ou nanossegundos. Verifique o número de dígitos antes de converter.
- 10 dígitos: provavelmente segundos Unix
- 13 dígitos: provavelmente milissegundos Unix ou long do Java em milissegundos
- 16 dígitos: provavelmente microssegundos
- 19 dígitos: provavelmente nanossegundos
- Sempre nomeie colunas com a unidade, como created_at_ms
Por que milissegundos viram datas estranhas
Um valor em milissegundos tratado como segundos vira uma data muito distante no futuro. Um valor em segundos tratado como milissegundos vira uma data perto de janeiro de 1970. Os dígitos são o diagnóstico mais rápido.
- 1700000000000 como milissegundos = 2023-11-14 22:13:20 UTC
- 1700000000000 como segundos = por volta do ano 55840, dependendo da biblioteca
- 1700000000 como segundos = 2023-11-14 22:13:20 UTC
- 1700000000 como milissegundos = 1970-01-20 16:13:20 UTC
FAQ sobre milissegundos epoch
A milliseconds value treated as seconds becomes an extremely far-future date. A seconds value treated as milliseconds becomes a date near January 1970. The digits are the quickest diagnostic.
- 1700000000000 as milliseconds = 2023-11-14 22:13:20 UTC
- 1700000000000 as seconds = year 55840 range, depending on the library
- 1700000000 as seconds = 2023-11-14 22:13:20 UTC
- 1700000000 as milliseconds = 1970-01-20 16:13:20 UTC
Cross-language patterns for ms-to-date
The conversion is structurally the same in every language — divide by 1000 (carefully) or use a millisecond-aware constructor. The details that bite are precision loss and naming.
- JavaScript: new Date(1700000000000) — no division needed, Date is millisecond-based
- Python: datetime.fromtimestamp(1700000000000 / 1000, tz=timezone.utc) — float division, watch for precision loss
- Java: Instant.ofEpochMilli(1700000000000L) — exact millisecond precision preserved
- PostgreSQL: SELECT to_timestamp(1700000000000.0 / 1000) — to_timestamp expects seconds, not milliseconds
- SQLite: SELECT datetime(1700000000000 / 1000, 'unixepoch') — integer division drops fractional seconds
- Go: time.UnixMilli(1700000000000) — added in Go 1.17 specifically to avoid the seconds-vs-ms mix-up
- Ruby: Time.at(0, 1700000000000, :millisecond) for exact ms precision
- C#: DateTimeOffset.FromUnixTimeMilliseconds(1700000000000L).UtcDateTime
Related articles
FAQ
- Is epoch time in ms the same as Unix timestamp?
- It uses the same epoch, but the unit is milliseconds instead of seconds. Classic Unix timestamp usually means seconds.
- How many digits is an epoch millisecond timestamp?
- For current dates, epoch milliseconds are usually 13 digits.
- Does JavaScript use milliseconds or seconds?
- JavaScript Date uses milliseconds. Date.now() returns epoch milliseconds.
- How do I convert a Java long timestamp to a date?
- If the long is epoch milliseconds, use Instant.ofEpochMilli(value); if it is epoch seconds, use Instant.ofEpochSecond(value). Check the digit count first — 13 digits is usually milliseconds, 10 digits is usually seconds.