MakeTimestamp logo
MakeTimestamp

Guías

¿Qué es Unix Timestamp? Guía Completa del Tiempo Epoch

¿Qué es Unix Timestamp?

Un Unix timestamp (también conocido como tiempo Unix, tiempo POSIX o tiempo Epoch) es un sistema para rastrear el tiempo como un solo número. Representa el número de segundos que han transcurrido desde las 00:00:00 UTC del 1 de enero de 1970, excluyendo los segundos intercalares. Este momento en el tiempo se llama la época Unix.

Por ejemplo, el Unix timestamp 1704067200 representa 1 de enero de 2024, 00:00:00 UTC.

Características Principales

  • Simple: Solo un número para representar cualquier momento en el tiempo
  • Universal: Funciona igual en todas las zonas horarias y sistemas
  • Eficiente: Fácil de almacenar, comparar y calcular
  • Estandarizado: Ampliamente adoptado en lenguajes de programación y bases de datos

¿Por qué Unix Timestamp comienza el 1 de enero de 1970?

El Unix timestamp comienza el 1 de enero de 1970 porque es cuando se estaba desarrollando el sistema operativo Unix. Los desarrolladores necesitaban un punto de referencia para su sistema de tiempo, y eligieron una fecha reciente y redonda que fuera fácil de recordar.

Esta fecha se conoce como la época Unix o tiempo epoch. Todos los Unix timestamps se calculan como el número de segundos desde este momento.

Contexto Histórico

  • 1969-1970: Desarrollo del sistema operativo Unix en Bell Labs
  • Necesidad de simplicidad: Los desarrolladores querían una forma simple de rastrear el tiempo
  • Sistemas de 32 bits: Originalmente diseñado para trabajar con enteros de 32 bits
  • Adopción amplia: Se convirtió en el estándar para el cronometraje informático

Cómo funciona Unix Timestamp

Concepto Básico

Unix timestamp es simplemente un contador que incrementa en 1 cada segundo:

Época Unix (Inicio):  0          → 1 de enero de 1970, 00:00:00 UTC
Después de 1 segundo: 1          → 1 de enero de 1970, 00:00:01 UTC
Después de 1 hora:    3600       → 1 de enero de 1970, 01:00:00 UTC
Después de 1 día:     86400      → 2 de enero de 1970, 00:00:00 UTC
Después de 1 año:     31536000   → 1 de enero de 1971, 00:00:00 UTC
Hoy (2025):           ~1735689600 → Hora actual

Niveles de Precisión

Los Unix timestamps pueden tener diferentes niveles de precisión:

PrecisiónDígitosEjemploDescripción
Segundos101704067200Unix timestamp estándar
Milisegundos131704067200000Usado en JavaScript, Java
Microsegundos161704067200000000Sistemas de alta precisión
Nanosegundos191704067200000000000Cronometraje ultra-preciso

Unix Timestamp en Diferentes Lenguajes de Programación

JavaScript / Node.js

// Obtener Unix timestamp actual (milisegundos)
const timestamp = Date.now();
console.log(timestamp); // 1704067200000

// Obtener Unix timestamp en segundos
const timestampSeconds = Math.floor(Date.now() / 1000);
console.log(timestampSeconds); // 1704067200

// Convertir Unix timestamp a Date
const date = new Date(1704067200000);
console.log(date); // 2024-01-01T00:00:00.000Z

// Convertir Date a Unix timestamp
const timestamp2 = new Date('2024-01-01').getTime();
console.log(timestamp2); // 1704067200000

Python

import time
from datetime import datetime

# Obtener Unix timestamp actual
timestamp = time.time()
print(timestamp)  # 1704067200.123456

# Obtener Unix timestamp (entero)
timestamp_int = int(time.time())
print(timestamp_int)  # 1704067200

# Convertir Unix timestamp a datetime
dt = datetime.fromtimestamp(1704067200)
print(dt)  # 2024-01-01 00:00:00

# Convertir datetime a Unix timestamp
timestamp2 = datetime(2024, 1, 1).timestamp()
print(timestamp2)  # 1704067200.0

PHP

<?php
// Obtener Unix timestamp actual
$timestamp = time();
echo $timestamp; // 1704067200

// Convertir Unix timestamp a fecha
$date = date('Y-m-d H:i:s', 1704067200);
echo $date; // 2024-01-01 00:00:00

// Convertir fecha a Unix timestamp
$timestamp2 = strtotime('2024-01-01');
echo $timestamp2; // 1704067200
?>

Java

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;

// Obtener Unix timestamp actual (segundos)
long timestamp = Instant.now().getEpochSecond();
System.out.println(timestamp); // 1704067200

// Obtener Unix timestamp (milisegundos)
long timestampMillis = System.currentTimeMillis();
System.out.println(timestampMillis); // 1704067200000

// Convertir Unix timestamp a LocalDateTime
LocalDateTime dateTime = LocalDateTime.ofEpochSecond(
    1704067200, 0, ZoneOffset.UTC
);
System.out.println(dateTime); // 2024-01-01T00:00:00

// Convertir LocalDateTime a Unix timestamp
long timestamp2 = dateTime.toEpochSecond(ZoneOffset.UTC);
System.out.println(timestamp2); // 1704067200

Go

package main

import (
    "fmt"
    "time"
)

func main() {
    // Obtener Unix timestamp actual
    timestamp := time.Now().Unix()
    fmt.Println(timestamp) // 1704067200

    // Convertir Unix timestamp a Time
    t := time.Unix(1704067200, 0)
    fmt.Println(t) // 2024-01-01 00:00:00 +0000 UTC

    // Convertir Time a Unix timestamp
    timestamp2 := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC).Unix()
    fmt.Println(timestamp2) // 1704067200
}

Ventajas de Unix Timestamp

1. Simplicidad

Un solo número es más fácil de manejar que cadenas complejas de fecha/hora.

2. Independencia de Zona Horaria

Los Unix timestamps siempre están en UTC, eliminando la confusión de zonas horarias.

3. Cálculos Fáciles

Calcula diferencias de tiempo mediante resta simple:

const inicio = 1704067200; // 1 Ene, 2024
const fin = 1704153600;    // 2 Ene, 2024
const diferencia = fin - inicio; // 86400 segundos = 1 día

4. Almacenamiento Eficiente

Almacenar un solo entero es más eficiente que almacenar cadenas de fecha.

5. Ordenación y Comparación

Fácil de ordenar y comparar timestamps:

const timestamps = [1704153600, 1704067200, 1704240000];
timestamps.sort((a, b) => a - b); // Orden cronológico

Limitaciones de Unix Timestamp

1. Problema del Año 2038

En sistemas de 32 bits, los Unix timestamps desbordarán el 19 de enero de 2038, 03:14:07 UTC. Esto se debe a que los enteros con signo de 32 bits solo pueden representar valores hasta 2,147,483,647.

Solución: Usar timestamps de 64 bits, que pueden representar fechas muy lejanas en el futuro.

2. Segundos Intercalares

Los Unix timestamps ignoran los segundos intercalares, que ocasionalmente se añaden al UTC para compensar la rotación irregular de la Tierra.

3. Limitaciones de Precisión

Los Unix timestamps estándar (segundos) pueden no ser suficientemente precisos para algunas aplicaciones. Usa milisegundos o microsegundos para mayor precisión.

4. Legibilidad Humana

Los Unix timestamps no son legibles para humanos. Necesitas convertirlos para mostrar fechas significativas.

Casos de Uso Comunes

1. Timestamps en Bases de Datos

Almacena tiempos de creación y modificación eficientemente:

CREATE TABLE usuarios (
    id INT PRIMARY KEY,
    nombre_usuario VARCHAR(50),
    creado_en BIGINT,
    actualizado_en BIGINT
);

2. Respuestas de API

Incluye timestamps en respuestas de API:

{
  "id": 123,
  "mensaje": "Hola Mundo",
  "timestamp": 1704067200,
  "creado_en": 1704067200
}

3. Archivos de Log

Rastrea cuándo ocurren eventos:

[1704067200] INFO: Usuario inició sesión
[1704067205] WARNING: Intento de inicio de sesión fallido
[1704067210] ERROR: Falló la conexión a la base de datos

4. Caché y Expiración

Establece tiempos de expiración de caché:

const cacheExpiry = Date.now() / 1000 + 3600; // Expira en 1 hora

5. Gestión de Sesiones

Rastrea timestamps de sesión de usuario:

const sessionStart = Math.floor(Date.now() / 1000);
const sessionExpiry = sessionStart + 1800; // 30 minutos

Mejores Prácticas

1. Siempre Usa UTC

Almacena Unix timestamps en UTC para evitar problemas de zona horaria.

2. Elige la Precisión Apropiada

  • Usa segundos para la mayoría de aplicaciones
  • Usa milisegundos para aplicaciones web (JavaScript)
  • Usa microsegundos o nanosegundos para cronometraje de alta precisión

3. Usa Enteros de 64 bits

Evita el problema del Año 2038 usando timestamps de 64 bits.

4. Valida Timestamps

Verifica si los timestamps están dentro de rangos razonables:

function isValidTimestamp(timestamp) {
    const min = 0; // Época Unix
    const max = 2147483647; // Año 2038 para 32 bits
    return timestamp >= min && timestamp <= max;
}

5. Documenta la Precisión

Siempre documenta si tus timestamps están en segundos, milisegundos u otras unidades.

Convirtiendo Unix Timestamps

Herramientas en Línea

Usa MakeTimestamp.com para convertir Unix timestamps a fechas legibles y viceversa.

Línea de Comandos

Linux/Mac:

# Unix timestamp actual
date +%s

# Convertir Unix timestamp a fecha
date -d @1704067200

# Convertir fecha a Unix timestamp
date -d "2024-01-01" +%s

Windows PowerShell:

powershell
# Unix timestamp actual
[int][double]::Parse((Get-Date -UFormat %s))

# Convertir Unix timestamp a fecha
[DateTimeOffset]::FromUnixTimeSeconds(1704067200).DateTime

Conceptos Relacionados

ISO 8601

Un formato de fecha/hora estandarizado: 2024-01-01T00:00:00Z

RFC 3339

Formato de timestamp para Internet: 2024-01-01T00:00:00+00:00

Tiempo POSIX

Otro nombre para el tiempo Unix, definido por el estándar POSIX.

Tiempo Epoch

Término general para el tiempo medido desde un punto de inicio específico (época).

Preguntas Frecuentes

¿Qué representa Unix timestamp 0?

Unix timestamp 0 representa la época Unix: 1 de enero de 1970, 00:00:00 UTC.

¿Pueden ser negativos los Unix timestamps?

¡Sí! Los Unix timestamps negativos representan fechas anteriores al 1 de enero de 1970. Por ejemplo, -86400 representa el 31 de diciembre de 1969.

¿Por qué algunos timestamps tienen 13 dígitos?

Los timestamps de 13 dígitos están en milisegundos (comúnmente usados en JavaScript), mientras que los de 10 dígitos están en segundos.

¿Cómo convierto entre segundos y milisegundos?

  • Segundos a milisegundos: Multiplicar por 1000
  • Milisegundos a segundos: Dividir por 1000

¿Qué pasa después del Año 2038?

En sistemas de 64 bits, los Unix timestamps pueden representar fechas hasta el año 292,277,026,596. En sistemas de 32 bits, necesitarás actualizar o usar representaciones de tiempo alternativas.

¿Los Unix timestamps se ven afectados por las zonas horarias?

¡No! Los Unix timestamps siempre están en UTC. Las zonas horarias solo se aplican al mostrar el timestamp como una fecha legible para humanos.

Resumen

Unix timestamp es una forma simple, eficiente y universal de representar el tiempo como un solo número. Cuenta los segundos desde el 1 de enero de 1970 (la época Unix) y es ampliamente utilizado en programación, bases de datos y APIs.

Puntos Clave:

  • Unix timestamp = segundos desde el 1 de enero de 1970, 00:00:00 UTC
  • Simple, universal y eficiente para el seguimiento del tiempo
  • Disponible en múltiples niveles de precisión (segundos, milisegundos, etc.)
  • Cuidado con el problema del Año 2038 en sistemas de 32 bits
  • Siempre almacena timestamps en UTC

¿Listo para trabajar con Unix timestamps? ¡Prueba nuestro Convertidor Unix Timestamp para convertir entre timestamps y fechas legibles instantáneamente!