Comprender las marcas de tiempo Unix y Epoch
Comprende la época Unix, las unidades, UTC, la precisión entera, los límites de 2038 y 2106 y los segundos intercalares con ejemplos de código.
Una marca de tiempo sitúa un evento en una escala temporal. Para intercambiarla hay que acordar época, unidad y tipo de reloj. Un contador desde el arranque no es una fecha UTC. Convertidor Unix Timestamp / Epoch permite inspeccionar valores y zonas horarias sin transmitir los cálculos a un servidor.
La época Unix y el 1 de enero de 1970
El origen es 1970-01-01 00:00:00 UTC, una convención histórica de Unix sin significado físico especial. Otra época cambiaría el número, no el evento. NTP parte de 1900; GPS y algunos dispositivos utilizan otras referencias. Un número aislado no identifica su época.
Funcionamiento y marcas negativas
En la aritmética calendárica POSIX habitual, un día UTC nominal equivale a 86400 segundos: el comienzo del 2 de enero de 1970 vale 86400. Esto no implica que todos los días locales duren 24 horas. Los valores positivos siguen a la época; −1 es el último segundo de 1969. El número Unix no lleva una zona horaria incorporada.
Segundos, milisegundos, microsegundos y nanosegundos
| Unidad de la marca | 1 s | 1700000000 s |
|---|---|---|
| Segundos (s) | 1 | 1700000000 |
| Milisegundos (ms) | 1000 | 1700000000000 |
| Microsegundos (µs) | 1000000 | 1700000000000000 |
| Nanosegundos (ns) | 1000000000 | 1700000000000000000 |
Multiplica los segundos por 1000 para obtener milisegundos o por mil millones para nanosegundos. Cambiar de unidad no mejora la exactitud del reloj. JavaScript Date espera milisegundos y muchas interfaces C esperan segundos. Incluye la unidad en el nombre del campo.
UTC, desplazamientos y zonas IANA
2023-11-14 22:13:20 UTC y 23:13:20 en París representan el mismo instante. +01:00 es un desplazamiento concreto; Europe/Paris incluye reglas civiles y transiciones. Abreviaturas como CST son ambiguas entre regiones.
Horas inexistentes y repetidas
En París, 2024-03-31 02:30 no existe. 2024-10-27 02:30 aparece dos veces: 00:30 UTC y 01:30 UTC. El convertidor rechaza los huecos y permite elegir la primera o segunda aparición. El día del año se obtiene de los campos del calendario local, sin dividir una duración local entre 24 horas. Las reglas dependen de los datos IANA del navegador y pueden cambiar por decisiones políticas.
Cálculo detallado y valores de referencia
1700000000 s × 1000 = 1700000000000 ms, ambos 2023-11-14T22:13:20Z. Sumar 123456789 ns produce 1700000000123456789 ns y la fracción .123456789. Date muestra .123; el convertidor conserva aparte los 456789 ns restantes.
| Segundos Unix | ISO 8601 (UTC) |
|---|---|
| -1 | 1969-12-31T23:59:59Z |
| 0 | 1970-01-01T00:00:00Z |
| 1000000000 | 2001-09-09T01:46:40Z |
| 1700000000 | 2023-11-14T22:13:20Z |
| 2147483647 | 2038-01-19T03:14:07Z |
| 4294967295 | 2106-02-07T06:28:15Z |
−1 ns corresponde a 1969-12-31T23:59:59.999999999Z. El milisegundo que lo contiene es −1 ms. Truncar la división hacia cero mostraría erróneamente la época. Redondea el cociente hacia menos infinito y conserva el resto.
El límite de 2038: entero de 32 bits con signo
El rango es −2³¹ a 2³¹−1. El último segundo positivo, 2147483647, es 2038-01-19T03:14:07Z. El siguiente ya no cabe. En C el desbordamiento con signo tiene comportamiento indefinido; no dependas de un supuesto salto a 1901. Amplía los operandos antes de calcular y revisa almacenamiento y protocolos.
El límite de 2106: entero de 32 bits sin signo
El rango 0–4294967295 termina en 2106-02-07T06:28:15Z y no representa directamente fechas anteriores a 1970. Usar unsigned desplaza el límite y cambia la semántica de los negativos; no sustituye una migración duradera del formato.
Enteros de 64 bits y precisión
Los segundos con signo de 64 bits abarcan unos 292 mil millones de años por dirección; los nanosegundos de igual anchura, unos 292 años, hasta 2262 en el lado positivo. Las bibliotecas calendáricas pueden tener límites menores. Binary64 representa todos los enteros solo hasta 2⁵³−1. Los nanosegundos actuales necesitan BigInt o cadenas decimales en JavaScript. Un flotante de 32 bits no tiene la precisión de un entero de 32 bits.
Segundos intercalares y POSIX
POSIX no cuenta todos los segundos SI transcurridos desde 1970 ni asigna una marca ordinaria única al segundo UTC :60. Un sistema puede saltar, repetir o suavizar el ajuste. No conviertas a TAI o GPS con un desplazamiento supuesto constante para siempre. La resta del reloj civil no garantiza una duración física durante una corrección.
JavaScript / TypeScript
const timestampNs = BigInt("1700000000123456789");
const divisor = BigInt(1_000_000);
const q = timestampNs / divisor;
const ms = timestampNs < 0 && timestampNs % divisor !== BigInt(0)
? q - BigInt(1) : q;
if (ms < BigInt("-8640000000000000") || ms > BigInt("8640000000000000")) {
throw new RangeError("Date");
}
const iso = new Date(Number(ms)).toISOString();
console.log(iso);
console.log(timestampNs.toString());
Date muestra 2023-11-14T22:13:20.123Z; el entero original conserva la fracción completa. El convertidor comprueba el valor completo antes de crear Date y reconstruye ISO y RFC 3339 por separado. RFC 3339 usa años de cuatro cifras: fuera de 0000–9999 indica indisponibilidad. RFC 2822 muestra segundos enteros y exige un año desde 1900.
Python sin pasar por coma flotante
from datetime import datetime, timezone, timedelta
epoch = datetime(1970, 1, 1, tzinfo=timezone.utc)
instant = datetime(2023, 11, 14, 22, 13, 20, 123456, tzinfo=timezone.utc)
delta = instant - epoch
timestamp_us = ((delta.days * 86400 + delta.seconds) * 1_000_000
+ delta.microseconds)
restored = epoch + timedelta(microseconds=timestamp_us)
assert restored == instant
print(timestamp_us, restored.isoformat())
UTC explícito evita depender de la zona del equipo. timedelta conserva microsegundos enteros; timestamp() devuelve un flotante que puede redondear fracciones. datetime no almacena nanosegundos. Para IANA utiliza zoneinfo y define cómo interpretar horas repetidas.
C y sistemas embebidos
#include <stdint.h>
#include <inttypes.h>
#include <stdio.h>
int main(void) {
int64_t seconds = INT64_C(1700000000);
int64_t milliseconds = seconds * INT64_C(1000);
int64_t after_2038 = (int64_t)INT32_MAX + INT64_C(1);
printf("%" PRId64 " %" PRId64 "\n", milliseconds, after_2038);
return 0;
}
Estos productos caben en int64_t; una función general debe comprobar límites antes de multiplicar. Una CPU de 64 bits no garantiza time_t de 64 bits. Su serialización directa depende de ABI, anchura y orden de bytes. Especifica época, unidad, signo y anchura en el protocolo. Consulta Marcas de tiempo Unix en sistemas embebidos, API y bases de datos.
Errores frecuentes
- Entregar segundos a Date o adivinar la unidad por el número de dígitos.
- Convertir una cadena larga a Number antes de BigInt: no recupera los dígitos perdidos.
- Añadir dos veces el desplazamiento de zona.
- Aceptar 31 de febrero por normalización automática.
- Confundir resolución de presentación y exactitud del reloj.
Preguntas técnicas
¿Cambiar de zona modifica el timestamp?
Solo modifica su representación calendárica. Interpretar campos locales nuevos sí necesita una zona.
¿Un valor negativo admite fracciones?
Sí. −0.5 s es medio segundo antes de la época. Conserva el signo y el resto al convertir unidades.
¿El reloj actual consulta una referencia de red?
Lee el reloj del dispositivo sin consultar NTP. La sincronización del sistema determina su exactitud.
Herramientas y fuentes
Convertidor Unix Timestamp / Epoch · Marcas de tiempo Unix en sistemas embebidos, API y bases de datos · Tolerancia de frecuencia · PPM ↔ Hz.