Timestamp en Rust : SystemTime, Chrono et time

Obtenir un timestamp avec la bibliothèque standard

SystemTime représente l’heure système. duration_since renvoie un résultat à vérifier : une date antérieure à l’Epoch produit une erreur, et non une durée négative.

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

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

as_secs() renvoie un u64 ; as_millis(), un u128. Vérifiez la plage avant de réduire ces types. Pour chronométrer une opération, préférez std::time::Instant.

Convertir et formater avec Chrono

Ajoutez cette dépendance dans Cargo.toml. Chrono apporte les dates calendaires et le formatage qui manquent à 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 hors plage")?;
    let from_ms = DateTime::from_timestamp_millis(1711972800000)
        .ok_or("Timestamp hors plage")?;

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

Les constructeurs retournent None si la date dépasse leur plage. Le parseur renvoie un Result. Traitez ces cas pour une saisie utilisateur au lieu d’utiliser systématiquement unwrap().

Pour l’instant courant avec Chrono : let now = chrono::Utc::now();, puis now.timestamp() ou now.timestamp_millis().

Gérer les timestamps négatifs

Dans Chrono, DateTime::from_timestamp(-1, 0) correspond à 1969-12-31T23:59:59Z. Pour des millisecondes négatives, utilisez directement from_timestamp_millis : une division entière faite à la main peut perdre la fraction ou arrondir du mauvais côté de zéro.

Alternative : la crate time

Voici un programme indépendant. Activez explicitement les fonctionnalités de lecture et de formatage.

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

Choisir une représentation adaptée

Un décalage fixe ne contient pas les règles saisonnières d’un fuseau géographique. Avec Chrono, une bibliothèque complémentaire comme chrono-tz permet de travailler avec les noms IANA tels que Europe/Paris. Conservez l’unité dans votre contrat d’API et évitez de convertir les grandes valeurs en flottants.

Vérifiez un résultat dans le convertisseur Unix ou le convertisseur ISO 8601. Comparez les secondes, millisecondes et nanosecondes. Retrouvez aussi les équivalents en Go.

Références officielles

Rust — SystemTime · Chrono — DateTime · Chrono et les fuseaux · time — OffsetDateTime

Publié le 25 septembre 2026.