¿Qué es un timestamp Unix?
Un timestamp Unix (también conocido como tiempo de época, epoch time o tiempo POSIX) es la cantidad de segundos transcurridos desde las 00:00:00 UTC del 1 de enero de 1970, sin contar los segundos intercalares. Es la forma universal con la que los ordenadores almacenan un instante de tiempo, con independencia de las zonas horarias y del formato del calendario. Esta calculadora toma un timestamp en milisegundos (la unidad que devuelven la mayoría de los lenguajes de programación, por ejemplo el Date.now() de JavaScript) y lo convierte en segundos, minutos y días desde la época.
Cómo usarla
Introduce tu tiempo Unix en milisegundos en el campo y pulsa enviar. La herramienta realiza una división entera entre 1000 para darte los segundos Unix completos: el formato más habitual en bases de datos, APIs y en el comando date +%s de Linux. La tabla de resultados también muestra el valor original en milisegundos, además de los minutos y los días transcurridos, ideales para una comprobación rápida.
La fórmula explicada
La conversión principal es \( \text{Seconds} = \left\lfloor \frac{\text{Time (ms)}}{1000} \right\rfloor \). Dividir entre 1000 transforma los milisegundos en segundos, y la función floor (redondeo hacia abajo) elimina la parte fraccionaria para que obtengas un timestamp con segundos enteros. Los minutos usan \( \left\lfloor \frac{M}{60000} \right\rfloor \) y los días \( \left\lfloor \frac{M}{86400000} \right\rfloor \), ya que un día tiene 86 400 segundos = 86 400 000 ms.
Ejemplo resuelto
Supongamos que \( \text{now\_ms} = 1\,700\,000\,000\,000 \). Entonces $$\text{epoch\_s} = \left\lfloor \frac{1\,700\,000\,000\,000}{1000} \right\rfloor = 1\,700\,000\,000 \text{ segundos},$$ lo que corresponde al 14 de noviembre de 2023. Los minutos desde la época \( = \left\lfloor \frac{1\,700\,000\,000\,000}{60000} \right\rfloor = 28\,333\,333 \), y los días \( = \left\lfloor \frac{1\,700\,000\,000\,000}{86\,400\,000} \right\rfloor = 19\,675 \).
Tabla de conversión de unidades de tiempo Unix
El tiempo Unix cuenta el tiempo transcurrido desde la época, el 1 de enero de 1970 a las 00:00:00 UTC. Normalmente se almacena en segundos o en milisegundos. La tabla siguiente muestra unidades comunes en ambas.
| Unidad | Segundos | Milisegundos |
|---|---|---|
| 1 milisegundo | 0.001 | 1 |
| 1 segundo | 1 | 1,000 |
| 1 minuto | 60 | 60,000 |
| 1 hora | 3,600 | 3,600,000 |
| 1 día | 86,400 | 86,400,000 |
| 1 semana | 604,800 | 604,800,000 |
| 1 año común (365 días) | 31,536,000 | 31,536,000,000 |
Algunos lenguajes y sistemas usan una precisión más fina. Las marcas de tiempo en microsegundos tienen 1,000,000 unidades por segundo, y las marcas de tiempo en nanosegundos tienen 1,000,000,000 unidades por segundo. Para convertir milisegundos a segundos, divida entre 1,000 y redondee hacia abajo: \(\lfloor \text{ms} / 1000 \rfloor\).
Tenga en cuenta que el tiempo Unix ignora los segundos intercalares, por lo que cada día se cuenta como exactamente 86,400 segundos.
Valores de referencia destacados de marcas de tiempo Unix
| Marca de tiempo (segundos) | Fecha y hora UTC | Nota |
|---|---|---|
| 0 | 1 ene 1970 00:00:00 | La época Unix |
| 1,000,000,000 | 9 sep 2001 01:46:40 | Mil millones de segundos |
| 1,500,000,000 | 14 jul 2017 02:40:00 | |
| 1,700,000,000 | 14 nov 2023 22:13:20 | |
| 2,000,000,000 | 18 may 2033 03:33:20 | Dos mil millones de segundos |
| 2,147,483,647 | 19 ene 2038 03:14:07 | Máximo de un entero con signo de 32 bits |
Los sistemas que almacenan segundos en un entero con signo de 32 bits se desbordan un segundo después de la última fila. Este es el "problema del año 2038". El almacenamiento de 64 bits lo evita.
Guía de longitud de dígitos
Para fechas actuales, el número de dígitos de una marca de tiempo indica su unidad:
| Dígitos | Unidad |
|---|---|
| 10 | Segundos |
| 13 | Milisegundos |
| 16 | Microsegundos |
| 19 | Nanosegundos |
Ejemplos de entradas y resultados comparados
Cada resultado se redondea hacia abajo: segundos = ⌊ms / 1000⌋, minutos = ⌊segundos / 60⌋, días = ⌊segundos / 86,400⌋.
| Entrada en milisegundos | Segundos | Minutos | Días |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 999 | 0 | 0 | 0 |
| 1,000 | 1 | 0 | 0 |
| 59,999 | 59 | 0 | 0 |
| 86,400,000 | 86,400 | 1,440 | 1 |
| 1,700,000,000,000 | 1700000000 | 28,333,333 | 19,675 |
Comprobación del último ejemplo: \(\lfloor 1{,}700{,}000{,}000{,}000 / 1000 \rfloor = 1{,}700{,}000{,}000\) segundos. Luego, \(1{,}700{,}000{,}000 / 60 = 28{,}333{,}333.33\), que se redondea hacia abajo a 28,333,333 minutos. Finalmente, \(1{,}700{,}000{,}000 / 86{,}400 = 19{,}675.9\), que se redondea hacia abajo a 19,675 días. El resto de 80,000 segundos equivale a 22 h 13 min 20 s, lo que coincide con 14 nov 2023 22:13:20 UTC.
Valores negativos: los tiempos anteriores a 1970 son negativos, y el redondeo hacia abajo se dirige hacia menos infinito, no hacia cero. Por ejemplo, -1 ms da -1 s, porque \(\lfloor -0.001 \rfloor = -1\). El truncamiento daría 0 en su lugar. La misma regla de redondeo hacia abajo se aplica a minutos y días.
Preguntas frecuentes
¿Por qué se usan segundos y no milisegundos en todas partes? Los sistemas más antiguos y muchas APIs (Unix, Postgres, los claims exp de JWT) almacenan segundos, mientras que los navegadores y Java utilizan milisegundos. Convertir entre ambas unidades es tan sencillo como multiplicar o dividir por 1000.
¿Y los segundos intercalares? El tiempo Unix ignora los segundos intercalares, por lo que el conteo es una medida lineal y limpia: cómoda para hacer cálculos, pero no perfectamente alineada con el UTC astronómico.
¿Fallará en 2038? Los sistemas que almacenan el conteo de segundos en un entero con signo de 32 bits sufrirán un desbordamiento el 19 de enero de 2038. Los sistemas modernos de 64 bits no se ven afectados.