Tech Help
De Unix Timestamp a data: segundos, milisegundos e UTC explicados
Converte un Unix timestamp nunha data. Mira segundos fronte a milisegundos, UTC fronte a hora local, ISO 8601 e como volver dunha data ao tempo epoch.
Un Unix timestamp representa o tempo respecto ao Unix epoch: 1970-01-01 00:00:00 UTC. A miúdo gárdase como segundos desde o epoch ou como milisegundos desde o epoch.
Para converter ben, primeiro hai que saber que unidade tes. 1720000000 segundos son 2024-07-03 09:46:40 UTC. 1720000000000 milisegundos son o mesmo instante.
O timestamp identifica un instante. UTC, a hora local ou unha zona IANA só cambian como se amosa ese instante.
Isto é unha guía de conversión: timestamp a data, data a timestamp, UTC fronte a local, e ISO 8601. Se un valor se torna de súpeto nunha data de 1970, adoita ser un desaxuste de segundos/milisegundos: véxase Unix Timestamp en segundos vs milisegundos: por que a data mostra 1970.
Que é un Unix Timestamp?
Unix timestamp, Unix time e epoch time adoitan significar o tempo transcorrido desde 1970-01-01 00:00:00 UTC. O número non é unha cadea de data formatada cunha etiqueta de fuso horario. O mesmo instante pode amosarse con horas distintas en UTC, Nova York, Toquio ou Seúl. Os Unix timestamps non son sempre segundos: na práctica os milisegundos son habituais.
Que é o Unix Epoch?
O Unix epoch é 1970-01-01 00:00:00 UTC. O timestamp 0 é ese instante. Un timestamp positivo é posterior ao epoch. Algúns sistemas admiten un timestamp negativo para un momento anterior ao epoch, mais o soporte da linguaxe e do rango de datas varía.
O meu timestamp está en segundos ou en milisegundos?
1720000000 son segundos; 1720000000000 son milisegundos; son o mesmo instante. Unha pista práctica: uns 10 díxitos adoitan ser segundos; uns 13, milisegundos. A conta de díxitos é só unha heurística. Datas pasadas ou futuras, outras unidades ou un epoch personalizado poden verse distintos. Convertedor de data e hora pode converter con segundos, milisegundos ou automático (≤10 díxitos como segundos, ≥13 como milisegundos): elixe a unidade cando a coñezas.
Por que a unidade incorrecta produce a data incorrecta?
JavaScript Date agarda milisegundos. Pasar 1720000000 como se fosen milisegundos dá 1970-01-20 21:46:40 UTC. Tratar milisegundos como segundos, ou ao revés, cae nunha data moi distinta. Para a senda de diagnóstico de 1970, véxase Unix Timestamp en segundos vs milisegundos: por que a data mostra 1970.
new Date(1720000000);
// 1970-01-20T21:46:40.000ZComo converter un Unix timestamp en segundos
Multiplica os segundos por 1000 para obter milisegundos. JavaScript Date baséase en milisegundos, así que usa new Date(timestamp * 1000).
const timestamp = 1720000000;
const date = new Date(timestamp * 1000);
date.toISOString();
// 2024-07-03T09:46:40.000ZComo converter un timestamp en milisegundos
Pasa os milisegundos a Date de xeito directo. Non volvas multiplicar por 1000 un timestamp que xa está en milisegundos.
const timestamp = 1720000000000;
const date = new Date(timestamp);
date.toISOString();
// 2024-07-03T09:46:40.000ZPor que o mesmo timestamp amosa unha hora distinta?
Un Unix timestamp é un só instante. Amosalo en UTC, en hora local ou nunha zona IANA elixida cambia a hora do reloxo. Para 1720000000000, UTC é 2024-07-03 09:46:40. America/New_York nesa data é 2024-07-03 05:46:40 (EDT). Asia/Seoul é 2024-07-03 18:46:40 (UTC+9). Esos valores de Nova York e Seúl saen de Intl, non dun lema de desfase fixo.
Un Unix timestamp contén un fuso horario?
Non. Non garda America/New_York nin Asia/Seoul. O timestamp identifica un instante. O fuso horario aplícase ao formatar ese instante como data e hora lexibles. O epoch defínese respecto a UTC; o número en si non é «un campo de fuso horario UTC».
Unix Timestamp fronte a ISO 8601
1720000000 e 2024-07-03T09:46:40Z poden representar o mesmo instante. Unix é un valor numérico de tempo transcorrido. ISO 8601 é unha cadea de data e hora lexible e pode rematar en Z (UTC) ou nun desfase numérico. Z significa UTC; ás veces chámase Zulu. Non son o mesmo formato.
Como se obtén o Unix timestamp actual?
En JavaScript, Date.now() son milisegundos. Math.floor(Date.now() / 1000) son segundos. Non deixes un «agora» fixo nun artigo: móvese.
Date.now();
Math.floor(Date.now() / 1000);Pódese converter unha data de volta a Unix timestamp?
Si. Dende unha cadea ISO UTC explícita, getTime() devolve milisegundos; divide por 1000 e arredonda cara abaixo para segundos.
const date = new Date("2024-07-03T09:46:40Z");
date.getTime();
// 1720000000000
Math.floor(date.getTime() / 1000);
// 1720000000Coidado cos formatos de data ambiguos
03/07/2024 pode ser o 7 de marzo ou o 3 de xullo segundo a rexión. Prefire unha data e hora ao estilo ISO con fuso horario ou desfase. Convertedor de data e hora rexeita datas numéricas ambiguas como 01/02/2026 e pide un selector de data ou un valor ao estilo ISO.
E o horario de verán?
Un Unix timestamp non garda unha marca de horario de verán. A vista local aplica as regras da zona. America/New_York usa desfases distintos no inverno e no verán, así que «Nova York é UTC-5» non sempre é certo.
Os Unix timestamps inclúen segundos intercalares?
O tempo POSIX/Unix típico non conta os segundos intercalares como segundos SI extra nunha escala continua. As plataformas poden diferir. Nunha conversión cotiá podes ignorar este detalle.
Erros habituais ao converter un Unix timestamp
Estas confusións producen a data incorrecta ou a hora incorrecta no reloxo:
Segundos tratados como milisegundos
Un valor moderno en segundos acaba preto de 1970 en JavaScript Date.
Milisegundos tratados como segundos
A data salta moi lonxe no futuro.
Tratar 10 ou 13 díxitos como unha lei
A conta de díxitos é unha pista, non unha garantía.
Confundir UTC coa hora local
O instante é o mesmo; o reloxo amosado pode diferir.
Asumir que hai un fuso horario dentro do número
Os nomes IANA aplícanse ao amosar, non se gardan no timestamp.
Datas ambiguas, lemas de horario de verán ou un ×1000 de máis
Usa entrada ao estilo ISO. Non volvas multiplicar un timestamp en milisegundos.
Exemplos UTC verificados
Estas horas UTC calcularon-se, non se adiviñaron:
| Entrada | Unidade | UTC |
|---|---|---|
| 0 | segundos | 1970-01-01 00:00:00 |
| 1720000000 | segundos | 2024-07-03 09:46:40 |
| 1720000000000 | milisegundos | 2024-07-03 09:46:40 |
| 1720000000 | milisegundos | 1970-01-20 21:46:40 |
Unha guía simple para decidir a conversión
Se a fonte nomea a unidade, úsaa. Se non, a conta de díxitos é unha pista: despois comproba que a data pareza plausible. Converte segundos a milisegundos cando a API precise ms. Elixe UTC, local ou unha zona IANA para amosar. ISO 8601 serve para gardar e intercambiar.
- Tes un Unix timestamp
- Unidade indicada? Úsaa; se non, mira a magnitude
- Segundos? ×1000 se a API precisa milisegundos
- Milisegundos? Úsaos tal cal nunha API baseada en ms
- Amosa como UTC, local ou unha zona IANA
- Precisas unha cadea? ISO 8601 pode encaixar
O timestamp identifica un punto no tempo. UTC, a hora local ou un fuso horario só deciden como se amosa ese instante a unha persoa.
Converte Unix timestamps no teu navegador
NEXNARA Convertedor de data e hora converte segundos e milisegundos Unix, amosa UTC, hora local e ISO 8601, e converte entre fusos horarios IANA.
O modo Unix admite segundos, milisegundos, unidade automática, hora actual e data a timestamp. O modo de fuso horario busca nomes IANA, usa a zona do navegador e aplica desfases Intl con horario de verán. O modo de formato ten saída lexible segundo a rexión, visualización 12/24 e un filtro de datas ambiguas. A diferenza de datas é un modo á parte.
A conversión usa as API Date e Intl do navegador. Rexeítanse os valores que Date non pode representar. A unidade automática non adiviña valores de 11–12 díxitos; elixe segundos ou milisegundos.
A conversión de datas e timestamps ocorre no teu navegador. As entradas non se envían a un servidor de NEXNARA para convertelas. Os anuncios e outras funcións do sitio si usan a rede.
Pega un timestamp en Convertedor de data e hora e compara UTC, hora local e ISO 8601 antes de elixir a unidade.
FAQ
Como converto un Unix timestamp nunha data?
Coñece a unidade. En JavaScript, para segundos usa new Date(n * 1000). Para milisegundos, new Date(n). Logo formata como UTC, local ou unha zona.
O Unix timestamp está en segundos ou en milisegundos?
Pode ser calquera. Uns 10 díxitos adoitan ser segundos e uns 13 milisegundos, mais é unha heurística, non unha regra.
Por que o meu timestamp amosa 1970?
Adoita ser un valor en segundos lido como milisegundos. Véxase Unix Timestamp en segundos vs milisegundos: por que a data mostra 1970.
O Unix timestamp é sempre UTC?
O epoch defínese respecto a UTC, e o número identifica un instante. O fuso horario de visualización é á parte. Non é «un campo de fuso horario UTC» almacenado.
Un Unix timestamp contén un fuso horario?
Non. Non leva un identificador IANA. O fuso horario aplícase ao formatar o instante.
Como converto unha data a Unix timestamp?
Dende unha cadea ISO UTC, date.getTime() son milisegundos; Math.floor(date.getTime() / 1000) son segundos.