Timestamps en Rust: SystemTime, Chrono y time

Obtener un timestamp con la biblioteca estándar

SystemTime representa la hora del sistema. duration_since devuelve un resultado que debes comprobar: una fecha anterior a la época produce un error, no una duración negativa.

use std::time::{SystemTime, SystemTimeError, UNIX_EPOCH};

fn main() -> Result<(), SystemTimeError> {
    let elapsed = SystemTime::now().duration_since(UNIX_EPOCH)?;
    println!("Segundos: {}", elapsed.as_secs());
    println!("Milisegundos: {}", elapsed.as_millis());
    Ok(())
}

as_secs() devuelve un u64; as_millis(), un u128. Comprueba el rango antes de reducir estos tipos. Para cronometrar una operación, utiliza std::time::Instant.

Convertir y formatear con Chrono

Añade esta dependencia a Cargo.toml. Chrono proporciona las fechas de calendario y el formato que no ofrece SystemTime.

[dependencies]
chrono = "0.4"

use chrono::{DateTime, SecondsFormat};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let date = DateTime::from_timestamp(1711972800, 0)
        .ok_or("Timestamp fuera de rango")?;
    let from_ms = DateTime::from_timestamp_millis(1711972800000)
        .ok_or("Timestamp fuera de rango")?;

    assert_eq!(date, from_ms);
    println!("{}", date.to_rfc3339_opts(SecondsFormat::Secs, true));
    // 2024-04-01T12:00:00Z
    println!("{}", date.timestamp_millis()); // 1711972800000

    let parsed = DateTime::parse_from_rfc3339("2024-04-01T14:00:00+02:00")?;
    assert_eq!(parsed.timestamp(), date.timestamp());
    Ok(())
}

Los constructores devuelven None si la fecha supera su rango. El analizador devuelve un Result. Gestiona estos casos para las entradas del usuario en vez de utilizar siempre unwrap().

Para el instante actual con Chrono: let now = chrono::Utc::now();, después now.timestamp() o now.timestamp_millis().

Gestionar timestamps negativos

En Chrono, DateTime::from_timestamp(-1, 0) corresponde a 1969-12-31T23:59:59Z. Para milisegundos negativos, utiliza from_timestamp_millis directamente: la división entera manual puede perder la fracción o redondear al lado incorrecto del cero.

Alternativa: la crate time

Este es un programa independiente. Activa explícitamente las funcionalidades de análisis y formato.

[dependencies]
time = { version = "0.3", features = ["formatting", "parsing"] }

use time::{format_description::well_known::Rfc3339, OffsetDateTime};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let date = OffsetDateTime::from_unix_timestamp(1711972800)?;
    println!("{}", date.format(&Rfc3339)?);
    // 2024-04-01T12:00:00Z
    let parsed = OffsetDateTime::parse("2024-04-01T14:00:00+02:00", &Rfc3339)?;
    assert_eq!(parsed.unix_timestamp(), date.unix_timestamp());
    Ok(())
}

Elegir una representación adecuada

Un desfase fijo no contiene las reglas estacionales de una zona horaria geográfica. Con Chrono, una biblioteca complementaria como chrono-tz admite nombres IANA como Europe/Paris. Conserva la unidad en el contrato de tu API y evita convertir valores grandes a números de coma flotante.

Comprueba un resultado en el Conversor Unix o el Conversor ISO 8601. Compara segundos, milisegundos y nanosegundos. Consulta también los equivalentes en Go.

Referencias oficiales

Rust — SystemTime · Chrono — DateTime · Chrono y las zonas horarias · time — OffsetDateTime

Versión en español publicada el 26 de septiembre de 2026.