La gestion de la date et de l’heure est un aspect crucial de nombreuses applications, qu’il s’agisse de planifier des tâches, d’analyser des données, d’effectuer des calculs ou d’assurer la représentation des données.
Rust possède de nombreuses bibliothèques et modules permettant de travailler avec des dates et des heures. Rust fournit un module intégré temps pour les opérations liées au temps, et la bibliothèque Chrono interagit avec de nombreuses autres bibliothèques Rust pour les opérations liées à la date et à l’heure.
Premiers pas dans l’utilisation de la date et de l’heure en Rust
Chrono est une bibliothèque de date et d’heure qui permet de gérer les dates, les heures, les fuseaux horaires et les durées en Rust. Chrono fournit de nombreuses fonctionnalités et une API intuitive pour les types de date et d’heure, les fuseaux horaires et le décalage de la date, la durée et l’intervalle, l’analyse syntaxique et le formatage, et le travail avec les calendriers.
Chrono fonctionne bien avec d’autres bibliothèques dans l’écosystème Rust et s’intègre de manière transparente avec les traits d’E/S de la bibliothèque standard, ce qui vous permet de lire et d’écrire les valeurs de date et d’heure de Chrono depuis et vers divers flux.
En outre, Chrono prend en charge la sérialisation et la désérialisation par l’intermédiaire de la fonction Serde qui permet de travailler facilement avec les types Chrono en JSON, YAML, et d’autres formats. L’intégration de Chrono avec Serde permet d’effectuer des opérations sur la date et l’heure lors de la construction d’applications web en Rust.
Vous pouvez utiliser Chrono pour récupérer l’UTC (Coordinated Universal Time) de votre emplacement pour de nombreuses opérations telles que les conversions.
Ajoutez cette directive à la ligne de commande dépendances de votre Cargo.toml pour installer et utiliser le fichier chrono crate :
[dependencies]
chrono = "0.4.24"
Après l’installation du chrono vous pouvez utiliser chrono dans votre projet Rust en important le crate comme suit :
use chrono::prelude::*;
Chrono est l’un des crates Rust dont vous aurez besoin dans votre arsenal de développement, car il fournit la plupart des fonctionnalités pour les opérations sur la date et l’heure.
Les fuseaux horaires et la gestion du temps en Rust avec Chrono
Les fuseaux horaires garantissent la précision et la cohérence des horodatages et des informations temporelles dans différentes zones géographiques. Lorsque l’on travaille avec des données temporelles, il est essentiel de prendre en compte les fuseaux horaires afin d’éviter toute ambiguïté ou inexactitude. Des opérations telles que la comparaison d’horodatages, le calcul de durées ou la planification d’événements sans traitement approprié des fuseaux horaires peuvent produire des résultats inattendus.
Chrono permet de convertir les fuseaux horaires. Voici un exemple de conversion d’un fuseau horaire DateTime d’un fuseau horaire à un autre :
use chrono::{DateTime, Utc, Local, TimeZone};
fn convert_timezone() {
let utc_time: DateTime<Utc> = Utc::now();
let local_time: DateTime<Local> = utc_time.with_timezone(&Local);
println!("UTC time: {}", utc_time);
println!("Local time: {}", local_time);
}
Le convert_timezone récupère l’UTC actuel à l’aide de la fonction Utc::now convertit l’UTC en fuseau horaire local avec la méthode with_timezone qui fait référence à la méthode Local et renvoie un DateTime objet représentant le même point dans le temps mais dans le fuseau horaire local.
Lorsque vous appelez la fonction convert_timezone elle affichera l’heure UTC et l’heure locale sur la console.
En outre, Chrono propose des méthodes et des fonctionnalités pratiques pour l’heure d’été (DST) et les décalages de fuseaux horaires. Dans votre système, vous pouvez ajuster l’horloge pour l’heure d’été via l’application Paramètres ou le Panneau de configuration.
Voici un exemple montrant les capacités de Chrono avec l’heure d’été et les décalages horaires :
use chrono::{DateTime, Utc, FixedOffset};
fn handle_dst() {
let utc_time: DateTime<Utc> = Utc::now();
let ny_timezone = FixedOffset::east(5 * 3600);
// Eastern Daylight Time (EDT) UTC-4:00
let ny_time: DateTime<FixedOffset> = utc_time.with_timezone(&ny_timezone);
println!("UTC time: {}", utc_time);
println!("New York time: {}", ny_time);
}
Le handle_dst accède à l’heure actuelle avec la fonction maintenant et récupère l’heure à New York en tenant compte du décalage avec la méthode FixedOffset::east méthode.
En appelant la méthode avec_fuseau_horaire vous convertissez l’UTC en fuseau horaire de New York. Chrono gère les ajustements de l’heure en fonction de l’heure d’été appropriée et renvoie une valeur de DateTime objet.
Lorsque l’on travaille avec l’heure d’été, il est essentiel de se rappeler que les transitions de l’heure d’été se produisent à des dates et heures spécifiques. Le système Chrono DateTime struct est équipé pour gérer ces transitions et garantir une représentation précise du temps dans les différents fuseaux horaires.
Calculs de durée et d’intervalle
Une durée est un temps indépendant d’un point précis dans le temps. Vous pouvez avoir besoin de calculer la durée entre deux événements, de mesurer le temps écoulé, ou d’ajouter ou de soustraire une certaine quantité à un temps donné.
La bibliothèque standard Rust temps crate fournit des outils complets pour gérer efficacement les durées.
Voici comment vous pouvez mesurer le temps d’exécution d’une fonction avec la fonction temps crate :
use chrono::{DateTime, Utc};
use std::time::Instant;
fn main() {
let start = Instant::now();
// Perform some operation
// ...
let end = Instant::now();
let duration = end.duration_since(start);
println!("Elapsed time: {:?}", duration);
}
Les principal récupère l’heure actuelle à l’aide de la fonction Instantané méthode de l’encastrement temps caisse. Après l’opération, le principal récupère l’heure à cet instant et évalue la différence avec la fonction durée_depuis avant d’imprimer la différence de temps sur la console.
Sérialisation et désérialisation : Convertir une date et une heure JSON en structures Rust avec Chrono
Sérialiser et désérialiser des valeurs de date et d’heure à partir de JSON en utilisant Chrono et Serde est un processus simple. Tout d’abord, ajoutez l’élément serde et serde_json Les crates sont ajoutés aux dépendances de votre projet.
[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
Ensuite, vous devrez définir le type Rust et implémenter la méthode #[derive(Serialize, Deserialize)] attributs pour le type où vous spécifierez le type de données :
use chrono::{DateTime, Utc};
#[derive(Serialize, Deserialize)]
struct Meeting {
start_time: DateTime<Utc>,
end_time: DateTime<Utc>,
}
Vous pouvez sérialiser le Réunion struct à JSON avec Serde et les capacités de formatage de Chrono.
Voici comment convertir une instance de la structure Réunion type to JSON :
use serde_json::to_string;
fn main() {
let meeting = Meeting {
start_time: Utc::now(),
end_time: Utc::now(),
};
let json = to_string(&meeting).unwrap();
println!("{}", json);
}
Le principal crée une fonction Réunion L’instance de l’UTC avec l’UTC actuelle pour les champs avant d’utiliser l’instance de l’UTC avec l’UTC actuelle pour les champs. to_string pour convertir l’instance de la structure en une chaîne JSON imprimée sur la console.
Vous pouvez facilement désérialiser des données JSON de type date-heure dans un type struct avec la fonction serde_json from_str qui prend une chaîne JSON et renvoie une instance de structure.
use serde_json::from_str;
fn main() {
let json = r#"{"start_time": "2023-05-28T12:00:00Z", "end_time": "2023-05-28T14:00:00Z"}"#;
let meeting: Meeting = from_str(json).unwrap();
println!("{:#?}", meeting);
}
La fonction principal désérialise la chaîne JSON à partir du fichier json dans la variable réunion instance de la Réunion avant d’imprimer l’instance de la structure sur la console.
Vous pouvez construire des applications sophistiquées avec Rust
La robustesse, la facilité d’utilisation et les fonctionnalités étendues de Chrono en font un outil indispensable pour gérer les dates, les heures, les durées et les intervalles de vos applications. Vous pouvez garantir des calculs de temps précis, une planification efficace et des opérations fiables liées aux dates en tirant parti des capacités de Chrono.
L’un des principaux cas d’utilisation de Chrono est la création d’applications web. Vous pouvez utiliser Chrono pour les enregistrements de temps d’activité, le chronométrage de l’activité de l’utilisateur et d’autres opérations Web.