Formatos de timestamp Unix explicados

Todos los formatos de timestamp Unix de un vistazo

Un timestamp Unix es solo un número, y su formato es en realidad solo su unidad — con qué finura cuenta desde el 1 de enero de 1970 UTC. La unidad casi siempre se lee por el número de dígitos: 10 dígitos son segundos, 13 son milisegundos, 16 son microsegundos, 19 son nanosegundos. Los dos formatos de cadena, ISO 8601 y RFC 2822, son en cambio autodescriptivos. La tabla siguiente es todo el panorama; las secciones posteriores cubren cada formato y cómo distinguirlos.

El tiempo Unix en segundos — el formato universal

El formato más común: un entero de 32 o 64 bits que cuenta el número de segundos enteros desde el 1 de enero de 1970 00:00:00 UTC. Actualmente un número de 10 dígitos alrededor de 1700 millones.

• Ejemplo: 1700000000 = 2023-11-15 06:13:20 UTC
• Usado por: Python time.time(), PHP time(), Go time.Now().Unix(), Ruby Time.now.to_i, C time(NULL)
• Almacenado como: int de 32 bits (heredado, año máx. 2038), int de 64 bits (moderno, seguro durante miles de millones de años)
• Base de datos: MySQL UNIX_TIMESTAMP(), PostgreSQL EXTRACT(EPOCH FROM NOW())::BIGINT

• The Open Group — Seconds Since the Epoch (POSIX)

El tiempo Unix en milisegundos — el formato de JavaScript

Milisegundos desde el epoch Unix: un entero de 13 dígitos que ofrece precisión de milisegundos. Es el formato que el objeto Date de JavaScript usa internamente.

• Ejemplo: 1700000000000 = 2023-11-15 06:13:20.000 UTC
• Usado por: JavaScript Date.now(), Java System.currentTimeMillis(), .NET DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
• Convertir a segundos: Math.floor(ms / 1000)
• Convertir desde segundos: seconds * 1000

• MDN — Date.now() y el objeto Date
• Milisegundos vs segundos — cuándo usar cuál

ISO 8601 — el estándar legible por humanos

ISO 8601 es un estándar internacional para representar fechas y horas como cadenas. A diferencia de los timestamps Unix, es autodescriptivo: el formato codifica tanto la fecha/hora como el desfase de zona horaria.

• 2023-11-15T06:13:20Z — UTC (el sufijo Z significa UTC)
• 2023-11-15T01:13:20-05:00 — con desfase UTC explícito (EST)
• 2023-11-15T06:13:20.000Z — con milisegundos
• JavaScript: date.toISOString() siempre devuelve UTC con sufijo Z
• Python: datetime.isoformat(), Go: time.Format(time.RFC3339)

• ISO 8601 y RFC 3339 — la guía completa del formato

RFC 2822 — formato de fecha de correo y HTTP

RFC 2822 (actualizado por RFC 5322 para el correo, y reflejado por RFC 9110 para HTTP) es el formato de fecha legible usado en las cabeceras de correo y las respuestas HTTP. El Date.toUTCString() de JavaScript devuelve este formato.

• Ejemplo: Wed, 15 Nov 2023 06:13:20 GMT
• Usado en: cabeceras de respuesta HTTP (Last-Modified, Date, Expires), cabeceras de correo (Date:)
• JavaScript: date.toUTCString()
• Menos común en las API modernas pero aún muy presente en la infraestructura web

• RFC 5322 — Internet Message Format (la cabecera de fecha)

Cómo detectar el formato del timestamp

Cuando recibes un valor de timestamp desconocido, estas reglas identifican su formato. El número de dígitos resuelve cada caso numérico; los dos formatos de cadena son obvios a simple vista.

• Comprobación de sentido común: cualquier valor numérico debería decodificarse en una fecha creíble de la era actual (aproximadamente 2001–2038 para segundos de 10 dígitos)
• Una fecha cercana a 1970 o a miles de años significa que la unidad se leyó mal

Microsegundos y nanosegundos

Algunos sistemas de alta precisión usan unidades menores que el milisegundo. Son raras en el código de aplicación pero aparecen en sistemas de bajo nivel, internos de bases de datos y herramientas de observabilidad.

• Microsegundos (µs): entero de 16 dígitos — Rust SystemTime as_micros(), PostgreSQL clock_gettime()
• Nanosegundos (ns): entero de 19 dígitos — Go time.Now().UnixNano(), Rust SystemTime as_nanos()
• PostgreSQL EXTRACT(EPOCH) devuelve un número de punto flotante con los microsegundos como parte fraccionaria
• Convertir nanosegundos a segundos: dividir por 1 000 000 000 (1e9)

Resolución y precisión de fracciones de segundo

Cada formato anterior lleva una resolución temporal distinta. Elegir un formato es elegir con qué finura puedes distinguir dos momentos — desde un segundo hasta un nanosegundo.

• Resolución de 1 segundo: segundos Unix (10 dígitos), POSIX time_t tradicional
• 1 milisegundo: JavaScript Date, MongoDB BSON Date, Java Instant.toEpochMilli()
• 1 microsegundo: timestamps Chrome/WebKit, Python datetime.timestamp(), PostgreSQL timestamp precision 6
• 100 nanosegundos: Windows FILETIME, .NET DateTime.Ticks
• 1 nanosegundo: Java Instant (precisión completa), Go time.UnixNano(), JS Temporal.Instant.epochNanoseconds (BigInt)
• Picosegundo y por debajo: formato de cable PTP/IEEE 1588 (1/2^32 de segundo), campo de fracción de NTP
• Elige la resolución más gruesa que cubra tus necesidades — la precisión por debajo del segundo suele perderse al serializar a JSON o en un round-trip de cadena
• Al convertir entre formatos, pasa por milisegundos o nanosegundos Unix (vía BigInt) — es el mínimo común denominador que preserva la precisión

Conversores de formato de timestamp

Convierte entre el tiempo Unix y los formatos de timestamp específicos de plataforma que encuentras en la práctica:

• Conversor FILETIME
• Conversor de Ticks .NET
• Tiempo WebKit/Chrome
• Mac Absolute Time
• Timestamp Core Data
• Conversor de fecha Excel
• Timestamp NTP
• Conversor de tiempo GPS
• Conversor de día juliano