Unix Timestamp en segundos vs milisegundos: por que a data mostra 1970

Converteches un timestamp e caíches en xaneiro de 1970. Case nunca é un reloxo estragado. O número leu-se como milisegundos cando estaba en segundos—ou ao revés.

Que é un Unix timestamp?

Un Unix timestamp mide o tempo desde o Unix epoch: 1970-01-01 00:00:00 UTC. Adoita usar segundos enteiro. O mesmo instante pode gardarse tamén en milisegundos (segundos × 1.000). O número non indica a unidade.

Segundos vs milisegundos: a diferenza ×1.000

Un segundo son 1.000 milisegundos. Compara 1720000000 con 1720000000000. Se o primeiro é segundos e o segundo milisegundos, marcan o mesmo instante. Le o primeiro como milisegundos e a data salta cara a 1970.

Estes resultados UTC calcularon-se cos números de enriba, non se adiviñaron.

Valor	Unidade probable	Interpretación (UTC)
1720000000	Segundos	Data moderna lida como segundos: 2024-07-03 09:46:40 UTC
1720000000000	Milisegundos	O mesmo instante lido como milisegundos: 2024-07-03 09:46:40 UTC
1720000000 como milisegundos	Unidade incorrecta	Data preto de 1970: 1970-01-20 21:46:40 UTC

Por que o meu timestamp mostra 1970?

Se un valor en segundos se trata como milisegundos, o número é 1.000 veces máis pequeno do debido. JavaScript conta só un treito curto despois do Unix epoch, e a data queda en 1970:

const seconds = 1720000000;

new Date(seconds);
// 1970-01-20 21:46:40 UTC

new Date(seconds * 1000);
// 2024-07-03 09:46:40 UTC

Esa data de 1970 é o epoch máis un par de semanas. Multiplica os segundos por 1.000 antes de pasalos a Date.

• SEGUNDOS
• 1720000000
• × 1000
• ↓
• MILISEGUNDOS
• 1720000000000

• Valor en segundos
• ↓
• Tratado por erro como milisegundos
• ↓
• Data preto de 1970

10 díxitos son segundos e 13 milisegundos?

Nas datas actuais, 10 díxitos adoitan ser segundos e 13 milisegundos. É unha pista rápida, non unha regra de validación. O número de díxitos cambia co intervalo temporal, e algunhas API gardan microsegundos ou nanosegundos. Confirma a unidade coa documentación ou cunha data que teña sentido.

Por que pasa tanto en JavaScript

En JavaScript, un Date numérico son milisegundos desde o epoch. Moitos backends, bases de datos e ferramentas Unix aínda gardan segundos. Pasar un valor en segundos directo a Date é un erro frecuente:

const unixSeconds = 1720000000;

const wrong = new Date(unixSeconds);
const correct = new Date(unixSeconds * 1000);

wrong queda preto de 1970 (1970-01-20 21:46:40 UTC). correct é o instante moderno (2024-07-03 09:46:40 UTC).

Outros sistemas usan unidades distintas

Outras linguaxes, API e bases poden usar segundos ou milisegundos. Algúns gardan microsegundos ou nanosegundos. Non asumas que unha linguaxe usa sempre unha unidade: mira a documentación. Se o número está en JSON, Formatador e comparación de JSON fai lexible o campo; tampouco che dirá a unidade.

Como sei que unidade usa o meu timestamp?

Fai estas comprobacións por orde. O número de díxitos non abonda.

1. Consulta a documentación da API ou da base de datos.
2. Mira o número aproximado de díxitos.
3. Compara o valor cun timestamp moderno plausible.
4. Proba o valor como segundos e como milisegundos.
5. Comproba se a data resultante ten sentido.

Se unha interpretación cae en 1970 e a outra nunha data que recoñeces, a causa é o desaxuste de unidades.

Erros habituais con Unix timestamp

• Segundos interpretados como milisegundos. A data afúndese cara a 1970, como no exemplo de enriba.
• Milisegundos interpretados como segundos. A data salta ao futuro lonxano, ou a conversión falla.
• Multiplicar por 1.000 dúas veces. Un valor que xa era milisegundos faise enorme e a data avanza séculos.
• Dividir por 1.000 dúas veces. Un valor en segundos éncolhe outra vez, outra vez preto de 1970.
• Culpar o fuso horario. Un fuso pode mover horas ou o día do calendario. Non leva un timestamp moderno a 1970.
• Tratar unha data formatada como Unix timestamp. Un valor como 2024-07-03T09:46:40Z non é un número epoch. Analízao como data, non como segundos.

O fuso horario causa o problema de 1970?

Normalmente, non. Un fuso pode cambiar o reloxo mostrado e, preto da medianoite, a data do calendario. Non converte un Unix timestamp moderno en 1970. Se o resultado é 1970, mira primeiro segundos fronte a milisegundos.

Converter e comprobar un Unix timestamp

NEXNARA Convertedor de data e hora pode converter un Unix timestamp no navegador.

Pega segundos ou milisegundos Unix, usa o timestamp actual, mira UTC e a hora local, converte fusos e formata unha data. A detección automática adoita tratar 10 díxitos como segundos e 13 como milisegundos; aínda podes elixir a unidade.

A conversión faise no teu navegador. Esta ferramenta non envía datas nin timestamps a un servidor de NEXNARA. Os anuncios e outras funcións do sitio si usan a rede; iso é á parte da conversión.

Queres comprobar un Unix timestamp? Abre Convertedor de data e hora e compara segundos con milisegundos.

FAQ

Por que o meu Unix timestamp mostra 1970?

A miúdo son segundos lidos como milisegundos. JavaScript trata un número moito menor, así que a data cae pouco despois de 1970-01-01 00:00:00 UTC. Multiplica os segundos por 1.000 e volta converter.

Os Unix timestamp son segundos ou milisegundos?

A miúdo usan segundos. Moitas API web e Date en JavaScript usan milisegundos. Mira sempre o que documenta ese sistema. Algúns usan microsegundos ou nanosegundos.

Como converto segundos a milisegundos?

Multiplica por 1.000. 1720000000 segundos son 1720000000000 milisegundos. Ao revés, divide por 1.000.

Por que Date en JavaScript usa milisegundos?

O timestamp numérico de Date en JavaScript defínese como milisegundos desde o Unix epoch. Por iso new Date(unixSeconds) é incorrecto se unixSeconds son segundos Unix.

Un timestamp de 10 díxitos é sempre segundos?

Non. Nas datas actuais adoita selo, e 13 díxitos adoitan ser milisegundos. A conta de díxitos é unha pista, non unha regra. Confírmao coa documentación ou unha data coherente.

Un Unix timestamp inclúe fuso horario?

Non. Un Unix timestamp é un instante contado desde 1970-01-01 00:00:00 UTC. Os fusos afectan a como se mostra, non o número.