#Chrono : Bibliothèque de dates et heures en Rust

Chrono vise à fournir toutes les fonctionnalités nécessaires pour manipuler correctement les dates et heures selon le calendrier grégorien :

• Le type DateTime est par défaut conscient des fuseaux horaires, tout en offrant des types indépendants du fuseau.
• Les opérations pouvant générer des dates ou heures invalides ou ambiguës renvoient Option ou MappedLocalTime.
• Analyse et formatage configurables avec une syntaxe inspirée de strftime.
• Le fuseau horaire Local fonctionne avec le fuseau actuel du système d'exploitation.
• Les types et opérations sont implémentés en tenant compte d'une efficacité raisonnable.
• Pour limiter la taille binaire, Chrono ne contient pas de données de fuseaux par défaut. Utilisez les crates Chrono-TZ ou tzfile pour un support complet.

#Fonctionnalités

Chrono prend en charge divers environnements d'exécution et systèmes d'exploitation avec plusieurs fonctionnalités activables.

#Fonctionnalités par défaut :

• alloc : Active les fonctionnalités nécessitant une allocation mémoire (principalement le formatage de chaînes).
• std : Active les fonctionnalités dépendant de la bibliothèque standard. Étend alloc avec l'interopérabilité des types standards.
• clock : Permet de lire le fuseau local (Local). Étend now.
• now : Active la lecture de l'heure système (now).
• wasmbind : Fournit une interface avec l'API JS Date pour les cibles wasm32.

#Fonctionnalités optionnelles :

• serde : Active la sérialisation/désérialisation via serde.
• rkyv : Obsolète, utilisez rkyv-*.
• rkyv-16, rkyv-32, rkyv-64 : Active rkyv avec des entiers de 16, 32 ou 64 bits.
• rkyv-validation : Active la validation rkyv avec bytecheck.
• arbitrary : Permet de créer des instances arbitraires avec le crate Arbitrary.
• unstable-locales : Active la localisation. Ajoute des méthodes suffixées par _localized.

#Aperçu

#Intervalles/Durées

Chrono fournit le type TimeDelta pour représenter des durées. C'est une durée "exacte" en secondes et nanosecondes, sans composants "nominaux" comme les jours ou mois.

Anciennement nommé Duration (toujours disponible comme alias), TimeDelta se distingue de core::time::Duration par sa nature signée.

#Dates et heures

Le type DateTime représente une date et heure avec fuseau horaire.

DateTime est conscient du fuseau et doit être construit depuis un objet TimeZone, qui définit la conversion entre dates locales et UTC. Trois implémentations majeures existent :

• Utc pour le temps universel. Le plus efficace.
• Local pour le fuseau système.
• FixedOffset pour un décalage fixe arbitraire (ex: UTC+09:00).

Les conversions entre fuseaux s'effectuent via DateTime::with_timezone.

Obtenez l'heure actuelle avec Utc::now() ou Local::now() :

use chrono::prelude::*;

let utc: DateTime<Utc> = Utc::now(); // Ex: `2014-11-28T12:45:59.324310806Z`
let local: DateTime<Local> = Local::now(); // Ex: `2014-11-28T21:45:59.324310806+09:00`

Créez aussi des dates/heures personnalisées :

use chrono::offset::MappedLocalTime;
use chrono::prelude::*;

let dt = Utc.with_ymd_and_hms(2014, 7, 8, 9, 10, 11).unwrap(); // `2014-07-08T09:10:11Z`

#Formatage et analyse

Le formatage utilise la méthode format avec une syntaxe similaire à strftime.

to_string et {:?} fournissent des représentations raisonnables. Les méthodes to_rfc2822 et to_rfc3339 couvrent les formats courants.

Le formatage localisé est disponible via unstable-locales :

use chrono::prelude::*;

let dt = Utc.with_ymd_and_hms(2014, 11, 28, 12, 0, 9).unwrap();
assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2014-11-28 12:00:09");
assert_eq!(dt.format_localized("%A %e %B %Y, %T", Locale::fr_BE).to_string(), 
           "vendredi 28 novembre 2014, 12:00:09");

Deux méthodes d'analyse existent :

1. Le trait standard FromStr (et parse) pour les types DateTime<FixedOffset>, DateTime<Utc> et DateTime<Local>.
2. DateTime::parse_from_str analyse avec décalage et renvoie DateTime<FixedOffset>.

use chrono::prelude::*;

let dt = "2014-11-28T12:00:09Z".parse::<DateTime<Utc>>().unwrap();
let fixed_dt = DateTime::parse_from_str("2014-11-28 21:00:09 +09:00", "%Y-%m-%d %H:%M:%S %z").unwrap();

#Conversion avec les timestamps UNIX

Utilisez DateTime::from_timestamp(seconds, nanoseconds) pour créer un DateTime<Utc> depuis un timestamp UNIX.

DateTime.timestamp extrait le timestamp (secondes), et DateTime.timestamp_subsec_nanos les nanosecondes additionnelles.

use chrono::{DateTime, Utc};

// Construction depuis l'epoch :
let dt: DateTime<Utc> = DateTime::from_timestamp(1_500_000_000, 0).unwrap();
assert_eq!(dt.to_rfc2822(), "Fri, 14 Jul 2017 02:40:00 +0000");

// Extraction depuis un datetime :
let dt = DateTime::parse_from_rfc2822("Fri, 14 Jul 2017 02:40:00 +0000").unwrap();
assert_eq!(dt.timestamp(), 1_500_000_000);

#Limitations

• Seul le calendrier grégorien proleptique est supporté.
• Les dates sont limitées à environ ±262 000 ans autour de l'ère commune.
• Précision temporelle limitée à la nanoseconde.
• Les secondes intercalaires sont représentables mais pas entièrement gérées.