Travailler avec les dates et l'heure en Rust : guide complet

Introduction au travail avec les dates et l'heure en Rust

Le travail avec les dates et l'heure est l'une des tâches clés dans la plupart des applications modernes. Que ce soit pour la journalisation d'événements, le calcul d'échéances, le traitement d'horodatages provenant d'API ou le travail avec un calendrier — une bibliothèque de qualité pour la gestion du temps est indispensable. Dans l'écosystème Rust, la bibliothèque standard ne fournit que des fonctionnalités de base (std::time::Instant et std::time::Duration), qui conviennent pour la mesure des performances, mais pas pour un travail complet avec les dates calendaires.

La crate chrono vient à la rescousse — c'est la norme de facto pour le travail avec les dates et l'heure en Rust. Elle offre un large éventail de fonctionnalités : de la création de dates simples au travail avec les fuseaux horaires, le formatage et l'arithmétique. Dans cet article, nous allons détailler les principales capacités de chrono, fournir des exemples pratiques et montrer comment éviter les erreurs typiques.

1. Installation et types principaux de chrono

Pour commencer, ajoutez la dépendance dans votre Cargo.toml :

[dependencies]chrono = "0.4"

Ensuite, vous pouvez importer les types nécessaires. Chrono propose trois types clés pour représenter les dates et l'heure :

• NaiveDate — date sans heure (année, mois, jour).
• NaiveDateTime — date et heure sans prise en compte du fuseau horaire.
• DateTime<Tz> — date et heure avec liaison à un fuseau horaire (par exemple, Utc ou Local).

Examinons un exemple très simple de création de ces types :

use chrono::{NaiveDate, NaiveDateTime, DateTime, Utc, Local};

fn main() {    // Créons une date naïve (sans heure)    let date = NaiveDate::from_ymd_opt(2025, 10, 15).unwrap();    println!("Date : {}", date);

    // Créons une heure naïve (sans date)    let time = NaiveTime::from_hms_opt(14, 30, 0).unwrap();    println!("Heure : {}", time);

    // Combinons en NaiveDateTime    let naive_dt = NaiveDateTime::new(date, time);    println!("Datetime naïf : {}", naive_dt);

    // Heure actuelle en UTC et locale    let now_utc: DateTime<Utc> = Utc::now();    let now_local: DateTime<Local> = Local::now();    println!("Maintenant UTC : {}", now_utc);    println!("Maintenant locale : {}", now_local);}

Notez l'utilisation de from_ymd_opt et from_hms_opt — elles retournent une Option, ce qui protège contre la création de dates invalides (par exemple, le 32 janvier).

2. Formatage et analyse des dates

Chrono utilise un système de formatage puissant basé sur des spécificateurs, très similaire à strftime de C/PHP. Cela permet de convertir flexiblement les dates en chaînes et vice versa.

2.1 Formatage d'une date en chaîne

use chrono::{Utc, DateTime};

fn main() {    let now: DateTime<Utc> = Utc::now();        // Standard ISO 8601    println!("ISO : {}", now.to_rfc3339());        // Format personnalisé    println!("Personnalisé : {}", now.format("%Y-%m-%d %H:%M:%S"));    println!("Jour de la semaine : {}", now.format("%A"));    println!("Mois : {}", now.format("%B"));    println!("Année-mois-jour : {}", now.format("%d.%m.%Y"));}

Spécificateurs de formatage principaux :

• %Y — année (4 chiffres)
• %m — mois (01-12)
• %d — jour du mois (01-31)
• %H — heures (00-23)
• %M — minutes (00-59)
• %S — secondes (00-60)
• %A — nom complet du jour de la semaine
• %B — nom complet du mois

2.2 Analyse d'une chaîne en date

Pour la conversion inverse, on utilise la méthode parse_from_str :

use chrono::{NaiveDateTime, DateTime, Utc, format::ParseResult};