Timestamp Rust: SystemTime, Chrono e time

Ottenere un timestamp con la libreria standard

SystemTime rappresenta l'ora di sistema. duration_since restituisce un risultato da controllare: una data prima dell'Epoch produce un errore, non una durata negativa.

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

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

as_secs() restituisce un u64; as_millis(), un u128. Controlla l'intervallo prima di restringere questi tipi. Per cronometrare un'operazione, preferisci std::time::Instant.

Convertire e formattare con Chrono

Aggiungi questa dipendenza a Cargo.toml. Chrono fornisce le date di calendario e la formattazione assenti in 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 fuori intervallo")?;
    let from_ms = DateTime::from_timestamp_millis(1711972800000)
        .ok_or("Timestamp fuori intervallo")?;

    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(())
}

I costruttori restituiscono None se la data supera l'intervallo supportato. Il parser restituisce un Result. Gestisci questi casi per l'input utente invece di usare sempre unwrap().

Per l'istante attuale con Chrono: let now = chrono::Utc::now();, poi now.timestamp() oppure now.timestamp_millis().

Gestire i timestamp negativi

In Chrono, DateTime::from_timestamp(-1, 0) corrisponde a 1969-12-31T23:59:59Z. Per i millisecondi negativi, usa from_timestamp_millis direttamente: una divisione intera manuale può perdere la frazione o arrotondare dal lato sbagliato dello zero.

Alternativa: la crate time

Ecco un programma separato. Abilita esplicitamente le funzionalità di parsing e formattazione.

[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(())
}

Scegliere una rappresentazione adatta

Un offset fisso non contiene le regole stagionali di un fuso geografico. Con Chrono, una libreria complementare come chrono-tz supporta nomi IANA come Europe/Paris. Mantieni l'unità nel contratto API ed evita di convertire valori grandi in numeri in virgola mobile.

Verifica un risultato nel convertitore Unix oppure nel convertitore ISO 8601. Confronta secondi, millisecondi e nanosecondi. Vedi anche gli equivalenti in Go.

Riferimenti ufficiali

Rust — SystemTime · Chrono — DateTime · Chrono e fusi orari · time — OffsetDateTime

Versione italiana pubblicata il 26 settembre 2026.