ToolActToolAct

Conversor de Marca de Tiempo

Convierte entre marcas de tiempo Unix y formatos de fecha y hora

0
Clic para copiar (Hora de Pekín UTC+8)

Marca de Tiempo a Fecha

Formato Estándar-
ISO 8601-
Formato Chino-
Formato Personalizado-

Fecha a Marca de Tiempo

Marca de Tiempo (segundos)-
Marca de Tiempo (milisegundos)-
Tiempo Unix-

Comparación de Zonas Horarias

北京 (UTC+8)--
东京 (UTC+9)--
新加坡 (UTC+8)--
伦敦 (UTC+0/+1)--
巴黎 (UTC+1/+2)--
纽约 (UTC-5/-4)--
洛杉矶 (UTC-8/-7)--
悉尼 (UTC+10/+11)--

Ejemplos de Formatos Comunes

YYYY-MM-DD HH:mm:ss
YYYY/MM/DD HH:mm:ss
YYYY-MM-DD
HH:mm:ss
YYYYMMDDHHmmss

¿Qué es una Marca de Tiempo?

Una marca de tiempo es un valor numérico que representa un momento específico. La marca de tiempo Unix es el número de segundos transcurridos desde el 1 de enero de 1970 00:00:00 UTC (llamada época Unix). Es la forma estándar de representar tiempo en sistemas informáticos, con consistencia multiplataforma y multizona horaria. Las marcas de tiempo se dividen en nivel de segundos (10 dígitos) y nivel de milisegundos (13 dígitos). Las de segundos se usan comúnmente en sistemas Unix/Linux, mientras que las de milisegundos son comunes en JavaScript y otros lenguajes. Cuando se usa con otras personas, entradas, supuestos y resultado esperado deben quedar claros para evitar malinterpretaciones.

Cómo usar

De marca de tiempo a fecha

  1. Introduce una marca de tiempo Unix en la tarjeta izquierda
  2. Selecciona la zona horaria de destino (p. ej., hora de Pekín UTC+8)
  3. Haz clic en el botón de conversión para ver la fecha y hora convertida
  4. Los resultados incluyen: formato estándar, ISO 8601, formato en chino y más

De fecha a marca de tiempo

  1. Selecciona la fecha y hora en la tarjeta derecha
  2. Selecciona la zona horaria de origen usada por esa fecha y hora
  3. Haz clic en el botón de conversión para obtener la marca de tiempo Unix
  4. Los resultados incluyen marcas de tiempo en segundos y milisegundos

Consejos sobre zonas horarias

  • Comprueba si el valor original usa segundos o milisegundos; mezclar marcas de tiempo de 10 y 13 dígitos es una causa frecuente de fechas incorrectas.
  • Confirma siempre la zona horaria prevista al convertir fechas legibles, sobre todo en registros, tareas programadas y sistemas entre regiones.

Casos de uso

Convertir marcas de tiempo Unix en fechas legiblesPega una marca de tiempo en segundos o milisegundos y la herramienta detecta automáticamente valores cortos en segundos, los convierte a milisegundos cuando es necesario y muestra fechas en formato estándar, ISO, estilo chino y formato personalizado en la zona horaria seleccionada. Un valor de 10 dígitos se trata como segundos y uno de 13 dígitos como milisegundos, lo que captura el error de mezcla más común antes de que se propague a una fecha incorrecta.
Crear marcas de tiempo a partir de entrada de fecha y horaElige una fecha y hora local y conviértela a segundos, milisegundos y un comando Unix de ejemplo. Las acciones rápidas permiten establecer el campo de marca de tiempo a hoy, mañana, inicio de semana, inicio de mes o inicio de año. La conversión solo lee el reloj local del navegador, sin intervención de servicios de hora del servidor, consultas NTP ni API remotas, lo que mantiene el cálculo reproducible en cualquier máquina con el reloj correctamente ajustado.
Comparar la hora actual entre zonas horarias principalesLa página actualiza la marca de tiempo actual cada segundo, muestra la hora en vivo de ciudades como Pekín, Tokio, Londres, París, Nueva York, Los Ángeles y Sídney, y ofrece ejemplos de formatos comunes que se pueden copiar directamente. Los dos formatos mostrados, ISO 8601 y RFC 3339, son casi idénticos; ISO 8601 permite muchos separadores opcionales mientras que RFC 3339 es un perfil más estricto que fija el formato y requiere un desplazamiento explícito, siendo la opción más segura para logs y payloads de API.
Traducir líneas de registro entre formatosArrastra una entrada de log como '2024-05-12T08:30:00Z' o '1700000000' al campo de entrada, alterna entre formatos estándar, ISO, RFC, estilo chino y personalizado, y copia la variante que coincida con tu pipeline de logs o consulta grep.
Verificar la caducidad de caché TTL y JWTResta los segundos actuales de la época a un valor 'Cache-Control: max-age', o pega el claim exp de un JWT para confirmar si un token aún es válido, está a punto de expirar o ya ha caducado. Verifica siempre con el servicio emisor antes de revocar sesiones. Los sistemas heredados que almacenan segundos Unix en un entero con signo de 32 bits desbordarán el 2038-01-19 03:14:07 UTC, el llamado problema Y2038, por lo que cualquier firmware anterior a 2010 aún en servicio debe verificarse antes de pasar marcas de tiempo más allá de 2038.

Principio técnico

Una marca de tiempo Unix cuenta el tiempo transcurrido desde la Época Unix, definida como 1970-01-01T00:00:00Z, que es el punto cero que el tiempo POSIX usa para etiquetar cada instante posterior. El tiempo POSIX ignora deliberadamente los segundos intercalares: cada día calendario se trata como exactamente 86.400 segundos, por lo que dos marcas de tiempo que abarquen una inserción de segundo intercalar tendrán un desvío de un segundo respecto a un conteo estricto de reloj atómico, pero la ventaja es que la conversión entre segundos de época y campos calendario UTC se mantiene como un divmod limpio por 86.400. Los dos formatos que aparecen a diario son segundos (10 dígitos actualmente, p. ej. 1717000000) y milisegundos (13 dígitos, p. ej. 1717000000000). El Date.now() de JavaScript devuelve milisegundos desde la época y `new Date(ms)` espera milisegundos, mientras que el `date +%s` de Unix, el time.Unix de Go y la mayoría de las columnas TIMESTAMP de bases de datos usan segundos. La detección por longitud es la desambiguación habitual: un valor de 10 dígitos cae en el rango 2001-2286 si se lee como segundos, y el mismo valor leído como milisegundos estaría dentro de 1970. Mostrar una marca de tiempo requiere una zona horaria. UTC se escribe con el sufijo `Z`; otros desplazamientos usan `±HH:MM` (p. ej. `+08:00` para la hora estándar de China, `-05:00` para la hora estándar del este de EE. UU.). ISO 8601 permite varios separadores opcionales mientras que RFC 3339 es un perfil más estricto que los fija, razón por la cual las especificaciones de API suelen requerir RFC 3339 con un desplazamiento explícito. Los sistemas heredados que almacenan segundos de época en un entero con signo de 32 bits desbordan en el valor máximo positivo 2147483647, que corresponde a 2038-01-19T03:14:07Z (el problema Y2038); el almacenamiento de 64 bits empuja el límite muy por encima de cualquier relevancia humana.

  • La Época Unix está fijada en 1970-01-01T00:00:00Z y el tiempo POSIX ignora los segundos intercalares, por lo que cada día se trata como exactamente 86.400 segundos.
  • JavaScript Date.now() devuelve milisegundos; `Math.floor(Date.now() / 1000)` convierte a una marca de tiempo a nivel de segundos.
  • Límite Y2038: una marca de tiempo con signo de 32 bits desborda en 2147483647 = 2038-01-19T03:14:07Z; el almacenamiento de 64 bits evita este problema.
  • ISO 8601 vs RFC 3339: RFC 3339 es un perfil más estricto de ISO 8601 que requiere un desplazamiento explícito (`Z` o `±HH:MM`) y es preferido para APIs y registros.
  • ECMAScript Date está limitado a ±100.000.000 días desde la época (≈ ±273.785 años), razón por la cual `new Date(8.64e15)` y `new Date(-8.64e15)` son los límites absolutos.
  • Los claims JWT `exp`, `iat` y `nbf`, `Cache-Control: max-age` y Cookie `Expires` usan segundos Unix (RFC 7519, RFC 7234), así que súmalos o réstalos directamente contra `Math.floor(Date.now()/1000)`.
  • La zona horaria afecta la fecha y hora renderizada, pero no el valor de la marca de tiempo en sí; el mismo segundo de época se muestra como horas de reloj diferentes en UTC+8 y UTC-5.

Ejemplos

Convertir una marca de tiempo Unix de 10 dígitos a una fecha legible

Entrada:  1781526600
UTC:    2026-06-15 12:30:00
Pekín (UTC+8): 2026-06-15 20:30:00
ISO 8601:        2026-06-15T12:30:00Z

POSIX: IEEE 1003.1 define el tiempo Unix como segundos desde 1970-01-01 00:00:00 UTC (la Época)
ISO: ISO 8601 define el formato YYYY-MM-DDThh:mm:ssZ para una representación inequívoca de fecha y hora

Convertir una fecha de vuelta a marca de tiempo

Entrada:  2026-01-01 00:00:00 (UTC)
Segundos (10 dígitos):     1767225600
Milisegundos (13 dígitos): 1767225600000
Comando Unix:            date -d @1767225600

Nota: JavaScript Date.getTime() devuelve milisegundos; Python time.time() devuelve segundos (float)
POSIX: el tipo time_t es tradicionalmente un entero con signo de 32 o 64 bits

Distinguir entre segundos y milisegundos

1781526600     -> 10 dígitos, segundos   -> 2026-06-15 12:30:00 UTC
1781526600000  -> 13 dígitos, milisegundos -> 2026-06-15 12:30:00.000 UTC

Error común: un valor de 13 dígitos leído como segundos daría aproximadamente el año 74.000
Truco rápido: 10-11 dígitos = segundos (1970-2286), 13 dígitos = milisegundos (predeterminado en JavaScript)

Decodificar la claim exp de un JWT

Payload JWT: { "exp": 1798617600 }
Decodificado:     2027-01-01 00:00:00 UTC
Ahora actual: 1781526600
Válido por:   17.091.000 segundos (~198 días restantes)

RFC: RFC 7519 sección 2 define NumericDate como segundos desde la Época

Verificación del límite Y2038

Marca de tiempo máxima con signo de 32 bits: 2147483647
Decodificado:                      2038-01-19 03:14:07 UTC
Un segundo después:             2147483648 -> desbordamiento en sistemas legacy de 32 bits

Solución: usar time_t de 64 bits (predeterminado en Linux/macOS modernos) o almacenar como cadena ISO 8601
POSIX: los sistemas con time_t de 32 bits darán la vuelta tras 2038-01-19

Preguntas frecuentes

¿Qué es una marca de tiempo Unix?

El número de segundos transcurridos desde el 1970-01-01 00:00:00 UTC, la 'época Unix'. JavaScript y muchas API usan milisegundos desde la misma época (timestamp Unix × 1000). La página acepta ambos y muestra la fecha correspondiente en tu hora local y en UTC.

¿Segundos, milisegundos, microsegundos o nanosegundos?

Distintos sistemas usan distinta precisión. La función `time()` de Unix devuelve segundos. Date.now() de JavaScript devuelve milisegundos. Instant de Java admite nanosegundos. La página detecta automáticamente por número de dígitos: 10 dígitos = segundos (entre 2001-2286), 13 = milisegundos, 16 = microsegundos, 19 = nanosegundos.

¿Por qué es importante el 19 de enero de 2038?

Es el 'problema del año 2038': las marcas de tiempo Unix con signo de 32 bits desbordan a las 03:14:07 UTC del 2038-01-19. Los sistemas que aún usen un time_t de 32 bits volverán a 1901. Los sistemas modernos de 64 bits no se ven afectados durante miles de millones de años; los sistemas embebidos antiguos necesitan parche.

¿Cómo gestiona las zonas horarias?

Las marcas de tiempo Unix son inherentemente UTC. La página muestra tu hora local, UTC, y te permite elegir cualquier zona horaria IANA (Asia/Shanghai, America/New_York, Europe/London) para visualizaciones adicionales. El horario de verano se aplica automáticamente según la zona.

¿Por qué interpretar 'YYYY-MM-DD' asume UTC en algunos sitios?

Las fechas ISO 8601 sin zona horaria son ambiguas. El constructor Date de JavaScript trata las cadenas solo de fecha como UTC y las cadenas de fecha-hora como locales: una fuente notoria de errores de un día. La página es explícita sobre qué zona horaria aplica.

¿La conversión se hace localmente?

Sí. Los cálculos usan Date de JavaScript junto con Intl.DateTimeFormat. Ninguna marca de tiempo se sube.

¿Puedo generar una marca de tiempo futura?

Sí. Elige una fecha futura y la página devuelve la marca de tiempo correspondiente. Útil para fijar el claim exp de un JWT, fechas de prueba para cron, o ventanas de expiración de caché en código.