Cómo convertir timestamps Unix a fechas (y viceversa)

¿Qué es un timestamp Unix?

Un timestamp Unix (también llamado tiempo Unix, tiempo POSIX o tiempo epoch) es el número de segundos que han transcurrido desde 00:00:00 UTC del 1 de enero de 1970, sin contar los segundos intercalares. Ese momento se llama epoch Unix.

Por ejemplo:

• 0 = 1970-01-01 00:00:00 UTC (la epoch)
• 1.000.000.000 = 2001-09-09 01:46:40 UTC (el "billonio")
• 1.234.567.890 = 2009-02-13 23:31:30 UTC
• 1.700.000.000 = 2023-11-14 22:13:20 UTC
• 2.000.000.000 = 2033-05-18 03:33:20 UTC

Los timestamps Unix están en todas partes de la informática:

• Bases de datos: PostgreSQL, MySQL y SQLite almacenan el tiempo internamente como timestamps Unix (o con referencia a ellos).
• Sistemas de archivos: ext4, NTFS y APFS almacenan los mtimes de archivo como timestamps Unix.
• APIs: Las APIs JSON comúnmente devuelven timestamps como enteros, p. ej., `"created_at": 1700000000`.
• Logs: La mayoría de los sistemas de logging emiten timestamps en formato Unix.
• Lenguajes de programación: PHP, Python, JavaScript, Go, Rust y Java tienen soporte integrado.

La razón por la que los timestamps Unix son populares: son enteros simples, fáciles de comparar, fáciles de ordenar, independientes de la zona horaria (siempre se refieren a UTC) y triviales de almacenar. También hacen la aritmética simple: para encontrar la duración de dos eventos, reste sus timestamps.

Cómo leer un timestamp Unix

El modelo mental: imagine un reloj que comenzó a contar desde la medianoche UTC del 1 de enero de 1970, y ha estado contando segundos desde entonces. El timestamp Unix es la lectura de ese reloj.

``` 1 minuto = 60 segundos 1 hora = 3.600 segundos 1 día = 86.400 segundos (24 × 60 × 60) 1 semana = 604.800 segundos (7 × 86.400) 1 año ≈ 31.536.000 segundos (365,25 × 86.400, promedio) 1 década ≈ 315.360.000 segundos ```

Algunos anclajes mentales:

• 1.000.000.000 = 2001-09-09. El billonio Unix: el primer segundo con 10 dígitos.
• 1.500.000.000 = 2017-07-14. La marca de "1,5 mil millones".
• 2.000.000.000 = 2033-05-18. La primera fecha de 2 mil millones de segundos.
• El problema de 2038: Los enteros con signo de 32 bits se desbordan en 2.147.483.647, que es 2038-01-19 03:14:07 UTC. Después de eso, los timestamps Unix de 32 bits se desbordan a valores negativos.

Las fórmulas exactas de conversión

Timestamp a fecha humana

``` human_date = epoch + timestamp segundos (UTC) local_date = human_date convertida a zona horaria local ```

En la mayoría de los lenguajes de programación:

```python import datetime ts = 1700000000 utc = datetime.datetime.fromtimestamp(ts, tz=datetime.timezone.utc) # 2023-11-14 22:13:20+00:00 local = datetime.datetime.fromtimestamp(ts) # depende de la zona horaria de su sistema ```

```js const ts = 1700000000; const date = new Date(ts * 1000); // JS usa milisegundos // 2023-11-14T22:13:20.000Z ```

Fecha humana a timestamp

``` timestamp = (date - epoch) en segundos ```

```python import datetime d = datetime.datetime(2023, 11, 14, 22, 13, 20, tzinfo=datetime.timezone.utc) ts = int(d.timestamp()) # 1700000000 ```

```js const d = new Date("2023-11-14T22:13:20Z"); const ts = Math.floor(d.getTime() / 1000); // 1700000000 ```

Zonas horarias comunes (relativas a UTC)

Cuando trabaja con timestamps, a menudo necesita mostrar en una zona horaria específica:

| Zona horaria | Abreviatura | Offset | Ciudades de ejemplo | |------------------------------------|-------------|-----------------|------------------------------| | Tiempo Universal Coordinado | UTC | 0 | Londres (invierno), Reikiavik| | Hora Estándar del Este | EST | UTC−5 | Nueva York (invierno) | | Hora de Verano del Este | EDT | UTC−4 | Nueva York (verano) | | Hora Estándar del Pacífico | PST | UTC−8 | Los Ángeles (invierno) | | Hora de Verano del Pacífico | PDT | UTC−7 | Los Ángeles (verano) | | Hora Central Europea | CET | UTC+1 | París (invierno), Berlín | | Hora de Verano Central Europea | CEST | UTC+2 | París (verano), Berlín | | Hora Estándar de Japón | JST | UTC+9 | Tokio | | Hora Estándar de China | CST | UTC+8 | Beijing, Shanghái | | Hora Estándar de la India | IST | UTC+5:30 | Mumbai, Delhi | | Hora Estándar del Este de Australia| AEST | UTC+10 | Sídney (invierno) | | Hora de Verano del Este de Australia| AEDT | UTC+11 | Sídney (verano) |

Tenga en cuenta que algunos países (India, China) observan un único offset durante todo el año sin horario de verano.

Método 1: Use el conversor de tiempo de UtilBoxx (Recomendado)

La forma más rápida, privada y precisa de convertir timestamps Unix en el navegador es el Conversor de Tiempo de UtilBoxx. Soporta tanto segundos como milisegundos, muestra en cualquier zona horaria, y muestra la fecha ISO 8601 correspondiente, UTC y hora local. Todo se ejecuta en su navegador: sin servidor, sin carga, sin registros.

Cómo usarlo:

1. Vaya a utilboxx.com/es/tools/unit/time
2. Escriba un timestamp Unix (en segundos) o una cadena de fecha
3. El valor convertido aparece al instante
4. Cambie entre zonas horarias con un clic
5. Copie el resultado

Por qué recomendamos este método:

• 100 % gratis, sin registro, sin email, sin anuncios
• Privacidad primero: nada sale de su navegador
• Bidireccional: timestamp ↔ fecha en cualquier dirección
• Multi-zona horaria: vea su timestamp en UTC, su zona local o cualquier zona
• Maneja milisegundos para timestamps estilo JavaScript
• Funciona en cualquier dispositivo con navegador

Si trabaja con APIs, logs o bases de datos que almacenan tiempo como timestamps Unix, esta herramienta se amortiza la primera semana.

Método 2: Python (módulo datetime)

El módulo `datetime` de Python es la herramienta canónica para la conversión de timestamps. Las dos funciones clave son `fromtimestamp()` y `timestamp()`.

```python import datetime from zoneinfo import ZoneInfo

# Convertir timestamp a fecha (UTC) ts = 1700000000 utc_date = datetime.datetime.fromtimestamp(ts, tz=datetime.timezone.utc) # 2023-11-14 22:13:20+00:00

# Convertir timestamp a fecha en una zona horaria específica ny_tz = ZoneInfo("America/New_York") ny_date = datetime.datetime.fromtimestamp(ts, tz=ny_tz) # 2023-11-14 17:13:20-05:00

# Convertir fecha a timestamp d = datetime.datetime(2023, 11, 14, 22, 13, 20, tzinfo=datetime.timezone.utc) ts = int(d.timestamp()) # 1700000000

# Ahora: timestamp actual now_ts = int(datetime.datetime.now(tz=datetime.timezone.utc).timestamp())

# Formatear fecha como ISO 8601 print(utc_date.isoformat()) # 2023-11-14T22:13:20+00:00 ```

Python 3.9+ también tiene la forma más simple `datetime.fromtimestamp(ts, tz=UTC)`, y el módulo `zoneinfo` (que reemplaza al antiguo `pytz`) facilita el manejo de zonas horarias.

Método 3: Bash / línea de comandos

El comando `date` en macOS y Linux puede tanto analizar como emitir timestamps Unix.

```bash # Convertir un timestamp Unix a una fecha legible (macOS / BSD) date -r 1700000000 # Tue Nov 14 22:13:20 UTC 2023

# Convertir un timestamp Unix (Linux / GNU date) date -d @1700000000 # Tue Nov 14 22:13:20 UTC 2023

# Obtener el timestamp Unix actual date +%s # 1700000000 (o lo que sea ahora)

# Convertir una cadena de fecha a timestamp Unix (GNU) date -d "2023-11-14 22:13:20 UTC" +%s # 1700000000

# Convertir una cadena de fecha a timestamp Unix (macOS) date -j -f "%Y-%m-%d %H:%M:%S" "2023-11-14 22:13:20" +%s # 1700000000

# Mostrar en una zona horaria específica TZ="America/New_York" date -d @1700000000 # Tue Nov 14 17:13:20 EST 2023 ```

La sintaxis difiere entre macOS y Linux. En macOS, `-r` lee un timestamp; en Linux, `-d @...` lee un timestamp y `-d "..."` analiza una fecha. Para scripting, la forma GNU (Linux) es más amigable; la forma macOS es más engorrosa pero funciona.

Método 4: JavaScript (en el navegador o Node.js)

JavaScript usa milisegundos para timestamps Unix, no segundos. Multiplique por 1.000 al ir de segundos a milisegundos.

```js // Timestamp actual en milisegundos const now = Date.now(); // p. ej., 1700000000000

// Convertir segundos a milisegundos y crear un Date const ts = 1700000000; const date = new Date(ts * 1000); // 2023-11-14T22:13:20.000Z

// Mostrar en una zona horaria específica usando Intl console.log(date.toLocaleString("en-US", { timeZone: "America/New_York" })); // 11/14/2023, 5:13:20 PM

// Mostrar como ISO 8601 console.log(date.toISOString()); // 2023-11-14T22:13:20.000Z

// Convertir fecha a timestamp (segundos) const d = new Date("2023-11-14T22:13:20Z"); const ts2 = Math.floor(d.getTime() / 1000); // 1700000000

// Analizar varios formatos new Date("2023-11-14"); // medianoche UTC new Date("2023-11-14T22:13:20Z"); // 22:13:20 UTC new Date(1700000000 * 1000); // desde milisegundos new Date("Nov 14, 2023 22:13:20");// análisis dependiente de locale (¡evitar!) ```

El objeto `Date` de JavaScript es famoso por ser peculiar. Para trabajo serio, use una biblioteca como `date-fns`, `Luxon` o `Day.js`. Para conversiones rápidas, el `Date` integrado está bien.

Preguntas frecuentes

¿Por qué la epoch Unix es el 1 de enero de 1970?

Es la fecha en que el sistema operativo Unix se implementó por primera vez. Ken Thompson y Dennis Ritchie la eligieron arbitrariamente al diseñar Unix en Bell Labs en 1969-1970. No hay razón astronómica o matemática; fue simplemente el comienzo de la década en la que estaban trabajando. Varios otros sistemas han elegido epochs diferentes: Windows FILETIME usa el 1 de enero de 1601; macOS HFS+ usó el 1 de enero de 1904; GPS usa el 6 de enero de 1980.

¿Qué es el problema de 2038?

El problema de 2038 (también llamado Y2K38) es el desbordamiento de entero con signo de 32 bits que ocurre el 19 de enero de 2038 a las 03:14:07 UTC. Un entero con signo de 32 bits puede contener valores hasta 2.147.483.647. Un segundo después, se desborda a −2.147.483.648, que se interpreta como 1901-12-13 20:45:52 UTC. Cualquier sistema que todavía use timestamps Unix de 32 bits (principalmente dispositivos embebidos, bases de datos antiguas y algunos sistemas de archivos) se romperá a menos que se actualice.

La solución es directa: cambiar a enteros de 64 bits, que extienden el rango de timestamp Unix en 290 mil millones de años. La mayoría de los sistemas modernos ya lo han hecho; el problema es principalmente con sistemas heredados y embebidos.

¿Los timestamps Unix están en segundos o milisegundos?

Depende del lenguaje:

• Segundos: C, Python, Go, Rust, Java (tradicionalmente), shell, SQL
• Milisegundos: JavaScript, Java (java.time.Instant), algunas bases de datos

JavaScript es el gran caso atípico con milisegundos, lo que lleva a errores cuando el código JavaScript se mezcla con código de otros lenguajes. Siempre aclare la unidad. El conversor de UtilBoxx maneja ambos con un solo interruptor.

¿Cómo afectan los segundos intercalares a los timestamps Unix?

Estrictamente hablando, los timestamps Unix ignoran los segundos intercalares. Cuentan cada segundo como si hubiera exactamente 86.400 por día. El UTC del mundo real tiene segundos intercalares ocasionales (añadidos para mantener el tiempo atómico alineado con la rotación de la Tierra), pero el tiempo Unix no los incluye. Esto significa que el tiempo Unix se desvía gradualmente del UTC en una fracción de segundo cada pocos años.

En la práctica, esto rara vez importa para el código de aplicación. NTP (Network Time Protocol) maneja la discrepancia. Si necesita TAI estricto o tiempo atómico, los timestamps Unix no son la herramienta adecuada.

¿Qué es "ISO 8601"?

ISO 8601 es un estándar internacional para formatos de fecha y hora, diseñado para ser inequívoco y legible por máquina. Ejemplos:

• `2023-11-14` (solo fecha)
• `2023-11-14T22:13:20` (fecha y hora, sin zona horaria)
• `2023-11-14T22:13:20Z` (UTC, "Z" = "Zulu time")
• `2023-11-14T22:13:20+05:00` (con offset de zona horaria)
• `2023-11-14T22:13:20.123Z` (con milisegundos)
• `20231114T221320Z` (forma compacta, sin separadores)

ISO 8601 es el formato recomendado para almacenar e intercambiar valores de fecha/hora porque se ordena lexicográficamente y se analiza sin ambigüedad. La mayoría de las APIs lo usan.

¿Cómo obtengo el timestamp Unix actual?

En todos los lenguajes principales:

```bash # bash date +%s ```

```python import time time.time() # 1700000000.123 (float, con segundos fraccionarios) int(time.time()) # 1700000000 (segundos enteros) ```

```js Date.now() / 1000 // 1700000000.123 Math.floor(Date.now() / 1000) // 1700000000 ```

Conclusión

Los timestamps Unix son el lenguaje universal del tiempo en la informática. Son enteros simples, fáciles de comparar, fáciles de almacenar e independientes de la zona horaria. La epoch es el 1 de enero de 1970 y los timestamps cuentan segundos desde entonces.

Para conversiones ocasionales, el Conversor de Tiempo de UtilBoxx es privado, gratis y funciona sin conexión una vez cargado. Para trabajo por lotes o con scripts, el `datetime` de Python o el comando `date` de bash manejan cualquier volumen de datos. Para trabajo interactivo, el `Date` de JavaScript está integrado en cada navegador.

El atajo mental: 1.000.000.000 = 2001 (billonio Unix), 1.500.000.000 = 2017, y 2.000.000.000 = 2033. Con estos anclajes, puede estimar el año de cualquier timestamp de 10 dígitos en su cabeza. Y recuerde: en 12 años llega el problema de 2038, así que audite sus timestamps de 32 bits ahora.