Skip to main content

Timestamp a fecha

Convierte una marca de tiempo en una fecha legible. Admite segundos, milisegundos y nanosegundos.

En 2038 un reloj de 32 bits no vuelve a 1970: aterriza en 1901

Una marca de tiempo con signo de 32 bits se agota en 2.147.483.647 segundos, es decir, el 19 de enero de 2038 a las 03:14:07 UTC. El segundo siguiente no vuelve a cero. Salta al valor más negativo que el tipo puede contener y deja el reloj en el 13 de diciembre de 1901: un sistema que falla así retrocede 137 años.

Cómo funciona

  • Convierte una marca de tiempo Unix en una fecha legible y al revés, en UTC y en hora local.
  • Detecta si la entrada está en segundos o milisegundos, que es el error más común.
  • Maneja marcas de tiempo negativas, que son válidas y representan fechas anteriores a 1970.
marca de tiempo = segundos transcurridos desde 1970-01-01 00:00:00 UTC

máximo de 32 bits con signo = 2.147.483.647 → 2038-01-19 03:14:07 UTC
  el segundo siguiente salta a −2.147.483.648 → 1901-12-13 20:45:52 UTC

máximo de 64 bits con signo ≈ 9,223 × 10¹⁸ segundos: unos 292.000 millones de años

Ejemplo resuelto

El mismo valor de diez dígitos leído de dos formas, más el límite que acaba con el tiempo de 32 bits.

  1. 1770000000 leído como segundos → 2026-02-02
  2. 1770000000 leído como milisegundos → 1970-01-21
  3. 10 dígitos significan segundos; 13 dígitos, milisegundos
  4. 2147483647 → 2038-01-19 03:14:07 UTC
  5. un segundo después → 1901-12-13 20:45:52 UTC

El peligroso es el error de unidad, porque falla en silencio. Leer milisegundos como segundos te lanza al año 58.000 y salta a la vista; leer segundos como milisegundos te deja en enero de 1970, que parece una fecha plausible y supera la revisión.

Cómo leer el resultado

  • Una fecha del 1 de enero de 1970 en producción casi siempre significa que llegó un nulo o un cero al formateador en lugar de una marca de tiempo real. La época es el valor por defecto de un entero sin inicializar, y por eso esa fecha aparece tantas veces en los informes de errores.
  • Las marcas de tiempo negativas son totalmente válidas y representan fechas anteriores a 1970: −86.400 es el 31 de diciembre de 1969. Los sistemas que las rechazan no pueden almacenar fechas históricas, lo cual es una limitación real y no una medida de seguridad.
  • La marca de tiempo en sí no lleva zona horaria; es un recuento absoluto de segundos. La zona entra solo al formatear, y por eso el mismo valor se representa como dos fechas de calendario distintas para dos usuarios, y por eso guardar hora local en lugar de una marca de tiempo causa tantos disgustos.
  • El tiempo Unix ignora por definición los segundos intercalares, repitiendo o estirando un segundo en lugar de contarlo. No es, por tanto, un recuento verdadero de segundos SI transcurridos, lo cual importa para medir intervalos con precisión y casi nunca para nada más.

Preguntas frecuentes

¿Por qué mi fecha aparece como 1970?
Porque el valor que llegó al formateador era cero o nulo, y cero es la época. Rara vez es un fallo de formato: la marca de tiempo nunca se estableció, o se perdió antes, y el 1 de enero de 1970 es el aspecto que tiene un entero sin establecer una vez representado.
¿Cómo distingo segundos de milisegundos?
Cuenta los dígitos. Las marcas de tiempo actuales tienen 10 dígitos en segundos y 13 en milisegundos. Tratar segundos como milisegundos es el error del que conviene protegerse, porque produce una fecha de principios de 1970 que parece real en lugar de obviamente absurda.

Guía del tiempo Unix

El tiempo Unix (tiempo epoch) es un sistema para almacenar fechas y horas como el número de segundos o milisegundos transcurridos desde la medianoche del 1 de enero de 1970 (UTC). Este estándar se usa ampliamente en programación, bases de datos y protocolos de red por su sencillez y la facilidad para comparar fechas. El valor 0 representa exactamente esa fecha, y cada segundo siguiente suma 1 al contador.

Distintos formatos de timestamp

El formato más común es Unix en segundos (ej. 1704067200), usado en sistemas Linux y PHP. El segundo formato popular es Unix en milisegundos (ej. 1704067200000), usado en JavaScript y la JVM. El tercero es en nanosegundos (ej. 1704067200000000), empleado en sistemas que requieren una precisión extrema, como bases de datos o sistemas financieros.

Problema del año 2038

El formato Unix tradicional en sistemas de 32 bits tiene un límite máximo de 2.147.483.647 segundos, que corresponde al 19 de enero de 2038. Pasada esa fecha, el valor pasa a negativo. Los sistemas modernos lo resuelven usando números de 64 bits, que durarán muchísimo tiempo. Las aplicaciones nuevas deberían usar milisegundos o nanosegundos para evitar problemas de compatibilidad.

Zonas horarias

El timestamp Unix siempre está en UTC, lo que significa que no contiene información de zona horaria. Para mostrar la fecha localmente, el sistema añade el desfase de la zona. Por ejemplo, el mismo valor de timestamp se mostrará una o dos horas antes en Polonia que en EE. UU. (según el horario de verano). Esto hace que el timestamp sea ideal para almacenar y transferir fechas entre zonas horarias.