¿Qué es el tiempo Unix?

El tiempo Unix (también llamado tiempo POSIX, tiempo Epoch o simplemente “una marca de tiempo”) es el número de segundos transcurridos desde el 1 de enero de 1970, 00:00:00 UTC, sin contar los segundos intercalares.

Tiempo Unix y zonas horarias: una referencia práctica de ingeniería

1736823600  →  14 de enero de 2026, 09:00:00 UTC

¿Por qué el 1 de enero de 1970? Era la época en que se desarrollaba el sistema operativo Unix y sus diseñadores necesitaban un punto de referencia fijo. La elección fue algo arbitraria, pero desde entonces se ha convertido en el estándar universal en prácticamente todos los sistemas operativos y lenguajes de programación.

Por qué los ordenadores usan el tiempo Unix

El tiempo Unix resuelve un problema sorprendentemente difícil: ¿cómo se ponen de acuerdo en qué hora es sistemas situados en zonas horarias distintas?

“Las 9:00 en Tokio” y “las 0:00 en Londres” ocurren en el mismo instante, pero se representan de forma distinta en la hora local. El tiempo Unix lo resuelve expresando el tiempo como un único entero medido en UTC. Las bases de datos, los registros y las API pueden guardar e intercambiar ese entero sin ninguna ambigüedad de zona horaria. La conversión a hora local se hace en la capa de presentación, no en el almacenamiento.


Segundos frente a milisegundos: la trampa más habitual

Este es el error que más quebraderos de cabeza causa al depurar.

Lenguaje / contexto Unidad Número de dígitos Ejemplo
Estándar Unix, time() de PHP, time.time() de Python Segundos 10 1736823600
Date.now() de JavaScript, System.currentTimeMillis() de Java Milisegundos 13 1736823600000
Algunos sistemas de registro Microsegundos 16 1736823600000000
Algunos sistemas de alta precisión Nanosegundos 19 1736823600000000000

El síntoma: pasas una marca de tiempo en milisegundos a una función que espera segundos y aparece una fecha de 1970. O al revés: pasas segundos a una función basada en milisegundos y obtienes una fecha de varias décadas en el futuro.

La solución: cuenta los dígitos. 10 dígitos → segundos. 13 dígitos → milisegundos.

function detectUnit(ts) {
  const digits = String(Math.abs(ts)).length;
  if (digits <= 10) return 'seconds';
  if (digits <= 13) return 'milliseconds';
  if (digits <= 16) return 'microseconds';
  return 'nanoseconds';
}

Trabajar con el tiempo Unix en lenguajes habituales

JavaScript / TypeScript

// Hora actual
const nowMs = Date.now();           // milisegundos
const nowSec = Math.floor(nowMs / 1000); // segundos

// De segundos Unix a un objeto Date
const ts = 1736823600;
const date = new Date(ts * 1000);   // hay que multiplicar por 1000
console.log(date.toISOString());    // "2026-01-14T09:00:00.000Z"

// De Date a segundos Unix
const unixSec = Math.floor(new Date('2026-01-14T09:00:00Z').getTime() / 1000);
console.log(unixSec);               // 1736823600

// Formato con Intl.DateTimeFormat (con zona horaria)
const formatter = new Intl.DateTimeFormat('ja-JP', {
  timeZone: 'Asia/Tokyo',
  dateStyle: 'full',
  timeStyle: 'long',
});
console.log(formatter.format(date)); // "2026年1月14日水曜日 18:00:00 JST"

Python

import time
from datetime import datetime, timezone, timedelta

# Hora actual
now_sec = time.time()         # float, segundos desde la época
now_int = int(time.time())    # segundos enteros

# De segundos Unix a datetime (UTC)
ts = 1736823600
dt_utc = datetime.fromtimestamp(ts, tz=timezone.utc)
print(dt_utc.isoformat())     # 2026-01-14T09:00:00+00:00

# Convertir a JST (UTC+9)
jst = timezone(timedelta(hours=9))
dt_jst = dt_utc.astimezone(jst)
print(dt_jst.isoformat())     # 2026-01-14T18:00:00+09:00

# De datetime a segundos Unix
ts_back = int(dt_utc.timestamp())

Go

import (
    "fmt"
    "time"
)

// Tiempo Unix actual
now := time.Now().Unix()          // int64, segundos
nowMs := time.Now().UnixMilli()   // int64, milisegundos

// De segundos Unix a time.Time
ts := int64(1736823600)
t := time.Unix(ts, 0).UTC()
fmt.Println(t.Format(time.RFC3339)) // 2026-01-14T09:00:00Z

// Convertir a JST
jst, _ := time.LoadLocation("Asia/Tokyo")
fmt.Println(t.In(jst).Format(time.RFC3339)) // 2026-01-14T18:00:00+09:00

SQL

-- PostgreSQL
SELECT to_timestamp(1736823600);                 -- 2026-01-14 09:00:00+00
SELECT EXTRACT(EPOCH FROM now())::bigint;        -- segundos Unix actuales

-- MySQL
SELECT FROM_UNIXTIME(1736823600);               -- 2026-01-14 09:00:00
SELECT UNIX_TIMESTAMP(NOW());                    -- segundos Unix actuales

-- SQLite
SELECT datetime(1736823600, 'unixepoch');        -- 2026-01-14 09:00:00
SELECT strftime('%s', 'now');                    -- segundos Unix actuales (cadena)

Gestión de zonas horarias

UTC es el único formato de almacenamiento seguro

No guardes nunca la hora local en una base de datos sin su desfase de zona horaria. Un valor como "2026-01-14 09:00:00" es ambiguo: ¿eran las 9:00 en Tokio (00:00 UTC) o las 9:00 en Nueva York (14:00 UTC)?

Regla: guarda segundos Unix (o TIMESTAMP WITH TIME ZONE en PostgreSQL, que se normaliza a UTC internamente) y convierte a hora local solo al mostrarla al usuario. Para el caso concreto de UTC↔JST (la tabla de desfases y las condiciones en las que JavaScript desplaza una fecha sin avisar), consulta la referencia de UTC a JST.

La trampa del horario de verano

El horario de verano (DST) hace que una hora local concreta pueda ser ambigua (cuando se retrasan los relojes, la misma hora local ocurre dos veces) o inexistente (cuando se adelantan, se salta una hora). UTC no tiene horario de verano: otro motivo para guardar en UTC y convertir al mostrar.

// Parece correcto, pero es frágil: el horario de verano puede desplazar el resultado una hora
const local = new Date('2026-03-08 02:30:00'); // Durante el cambio de DST de EE. UU.
// En su lugar, trabaja siempre en UTC:
const utc = new Date('2026-03-08T07:30:00Z');

Desfases de zona horaria habituales

Región Desfase estándar Desfase con horario de verano
UTC +00:00 —
JST (Japón) +09:00 Sin horario de verano
KST (Corea) +09:00 Sin horario de verano
CST (China) +08:00 Sin horario de verano
EST (este de EE. UU.) −05:00 −04:00 (EDT)
PST (oeste de EE. UU.) −08:00 −07:00 (PDT)
CET (Europa Central) +01:00 +02:00 (CEST)

Japón, Corea y China no aplican horario de verano, lo que simplifica mucho el tratamiento de la hora en los sistemas que operan en Asia Oriental.


El problema del año 2038

El tiempo Unix suele guardarse como un entero de 32 bits con signo. El valor máximo de un entero de 32 bits con signo es 2.147.483.647, que corresponde a:

19 de enero de 2038, 03:14:07 UTC

Pasado ese momento, un contador de 32 bits con signo se desborda y vuelve al valor negativo mínimo, con lo que las fechas aparecen como el 13 de diciembre de 1901. Se denomina Y2K38 o el error del milenio de Unix.

¿A quién afecta?

  • Sistemas embebidos (controladores industriales, firmware)
  • Código C heredado que usa time_t como int32_t
  • Algunos sistemas Linux de 32 bits
  • Esquemas de bases de datos antiguos que guardan las marcas de tiempo como INT(11)

La solución: usa enteros de 64 bits para guardar marcas de tiempo. Un entero de 64 bits con signo puede representar el tiempo hasta aproximadamente el año 292.000 millones: a efectos prácticos, para siempre.

Los lenguajes y las bases de datos modernos ya usan tiempo de 64 bits por defecto: el datetime de Python, el time.Time de Go, el Date de JavaScript (que usa internamente un número de coma flotante de 64 bits) y el tipo TIMESTAMP de PostgreSQL son seguros frente al problema de 2038. El riesgo está en el código C heredado y en ciertos entornos embebidos.


Referencia rápida de conversiones

Lo que tienes Lo que quieres Fórmula
Segundos Unix Milisegundos ts * 1000
Milisegundos Segundos Unix Math.floor(ts / 1000)
Segundos Unix Cadena ISO 8601 new Date(ts * 1000).toISOString()
Cadena ISO 8601 Segundos Unix Math.floor(new Date(str).getTime() / 1000)
Segundos Unix Hora local con formato Usa Intl.DateTimeFormat con timeZone

Preguntas frecuentes

¿Por qué new Date(1736823600) muestra una fecha de 1970?

Has pasado segundos donde se esperaban milisegundos. El constructor Date de JavaScript espera siempre milisegundos. Multiplica por 1000: new Date(1736823600 * 1000).

¿Qué diferencia hay entre UTC y GMT?

A efectos prácticos en el desarrollo de software, UTC y GMT son lo mismo. GMT (hora del meridiano de Greenwich) es una zona horaria histórica, mientras que UTC (tiempo universal coordinado) es el estándar internacional moderno. UTC se mantiene con relojes atómicos y se ajusta con segundos intercalares. Usa “UTC” en el código y en la documentación.

¿Debo usar Date.now() o new Date().getTime()?

Se prefiere Date.now(): es algo más rápido (no crea un objeto) y más expresivo. Ambos devuelven los milisegundos desde la época Unix.

¿Cómo gestiono la visualización de “tiempo relativo” (“hace 3 minutos”)?

Calcula la diferencia en segundos entre ahora y la marca de tiempo del evento y usa umbrales:

function timeAgo(unixSeconds) {
  const diff = Math.floor(Date.now() / 1000) - unixSeconds;
  if (diff < 60) return 'just now';
  if (diff < 3600) return `${Math.floor(diff / 60)} minutes ago`;
  if (diff < 86400) return `${Math.floor(diff / 3600)} hours ago`;
  return `${Math.floor(diff / 86400)} days ago`;
}

¿Afectan los segundos intercalares al tiempo Unix?

Técnicamente no: el tiempo Unix no cuenta los segundos intercalares. Esto significa que el tiempo Unix no es estrictamente continuo: en un segundo intercalar positivo, se repite el mismo valor de segundo. En la práctica, los sistemas operativos lo gestionan mediante el “difuminado de segundos intercalares” (repartir el ajuste a lo largo de varias horas), por lo que la mayoría del código de aplicación nunca tiene que preocuparse por ello.