Travailler avec la date et l'heure dans Rust

Travailler avec la date et l'heure dans Rust
Des lecteurs comme vous aident à soutenir MUO. Lorsque vous effectuez un achat en utilisant des liens sur notre site, nous pouvons gagner une commission d'affiliation. En savoir plus.

La gestion de la date et de l'heure est un aspect crucial de nombreuses applications, de la planification des tâches et de l'analyse des données à l'exécution des calculs et à la garantie de la représentation des données.





Rust possède de nombreuses bibliothèques et modules pour travailler avec les dates et les heures. Rust fournit un temps crate 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 de date et d'heure.



acheter des vêtements bon marché en ligne livraison gratuite dans le monde entier
UTILISEZ LA VIDÉO DU JOUR FAITES DÉFILER POUR CONTINUER AVEC LE CONTENU

Commencer à travailler avec la date et l'heure dans Rust

Chrono est une bibliothèque date-heure pour gérer les dates, les heures, les fuseaux horaires et les durées dans Rust. Chrono fournit plusieurs fonctionnalités et une API intuitive pour les types de date et d'heure, les fuseaux horaires et le décalage de la date et de l'heure, la durée et l'intervalle, l'analyse et le formatage et l'utilisation des calendriers.





Chrono fonctionne bien avec d'autres bibliothèques de l'écosystème Rust et s'intègre de manière transparente aux caractéristiques d'E/S de la bibliothèque standard, ce qui vous permet de lire et d'écrire des valeurs de date et d'heure Chrono depuis et vers divers flux.

De plus, Chrono prend en charge la sérialisation et la désérialisation via le Cœur crate, ce qui facilite le travail avec les types Chrono aux formats JSON, YAML et autres. L'intégration de Chrono avec Serde le rend adapté aux opérations de date-heure tout en créer des applications Web en Rust .



Vous pouvez utiliser Chrono pour récupérer votre position UTC (temps universel coordonné) pour de nombreuses opérations comme les conversions.

Ajoutez cette directive au dépendances rubrique de votre charge.toml fichier pour installer et utiliser le Chrono Caisse:



 [dependencies] 
chrono = "0.4.24"

Après avoir installé le Chrono caisse, vous pouvez utiliser Chrono dans votre projet Rust en important la caisse comme suit :

 use chrono::prelude::*;

Chrono est l'une des caisses Rust dont vous aurez besoin dans votre arsenal de développement car elle fournit la plupart des fonctionnalités pour les opérations de date et d'heure.



Fuseaux horaires et gestion du temps dans Rust With Chrono

Les fuseaux horaires garantissent que les horodatages et les informations relatives au temps sont exacts et cohérents dans divers emplacements géographiques. Lorsque vous travaillez avec des données temporelles, il est essentiel de prendre en compte les fuseaux horaires pour éviter toute ambiguïté et toute inexactitude. Des opérations telles que la comparaison d'horodatages, le calcul de durées ou la planification d'événements sans gestion appropriée du fuseau horaire peuvent produire des résultats inattendus.

Vous pouvez convertir entre les fuseaux horaires avec Chrono. Voici un exemple de conversion d'un DateHeure d'un fuseau horaire à l'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 la fonction récupère l'UTC actuel avec la UTC ::maintenant méthode, convertit l'UTC vers le fuseau horaire local avec la with_timezone méthode qui prend en référence Local structure et retourne un DateHeure objet représentant le même point dans le temps mais dans le fuseau horaire local.

Lorsque vous appelez le convert_timezone fonction, il imprimera l'UTC et l'heure locale sur la console.

résultat de l'impression de l'heure de New York

De plus, Chrono fournit des méthodes et des fonctionnalités pratiques pour l'heure d'été (DST) et les décalages de fuseau horaire. Dans votre système, vous pouvez régler 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 fonction accède à l'heure actuelle avec la touche maintenant méthode et récupère l'heure à New York tout en tenant compte de l'heure de décalage avec la FixedOffset :: est méthode.

En appelant le with_timezone fonction, vous convertissez l'UTC au fuseau horaire de New York. Chrono gère les ajustements de temps selon le DST approprié et renvoie un DateHeure objet.

résultat de l'impression de l'heure de New York

Lorsque vous utilisez DST, il est essentiel de se rappeler que les transitions DST se produisent à des dates et heures spécifiques. Chrono's DateHeure struct est équipé pour gérer ces transitions et assurer des représentations précises de l'heure dans différents fuseaux horaires.

Calculs de durée et d'intervalle

Une durée est un temps indépendant de tout point spécifique dans le temps. Vous devrez peut-être calculer la durée entre deux événements, mesurer le temps écoulé ou ajouter ou soustraire un certain montant à partir d'un temps spécifié.

La bibliothèque standard de 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 le temps Caisse:

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

Le principal fonction récupère l'heure actuelle avec la Instantané méthode de l'intégré temps Caisse. Après l'opération, le principal fonction récupère l'heure à cet instant et évalue la différence avec la durée_depuis fonction avant d'imprimer le décalage horaire sur la console.

Sérialisation et désérialisation : conversion de la date et de l'heure JSON en structures Rust à l'aide de Chrono

La sérialisation et la désérialisation des valeurs de date et d'heure à partir de JSON à l'aide de Chrono et Serde est un processus simple. Tout d'abord, ajoutez le cœur et serde_json crates 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 le #[dériver(sérialiser, désérialiser)] attributs pour le type où vous spécifierez le type de données :

raspberry pi changer de clavier pour nous 
 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 en JSON avec Serde aux côtés des capacités de formatage de Chrono.

Voici comment vous pouvez convertir une instance de Réunion tapez en 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 fonction crée un Réunion instance avec l'UTC actuel pour les champs avant d'utiliser le to_string fonction pour convertir l'instance de struct en une chaîne JSON imprimée sur la console.

Vous pouvez facilement désérialiser les données date-heure JSON dans un type de structure avec serde_json's from_str fonction 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); 
}

Le principal la fonction désérialise la chaîne JSON de la json variable dans le réunion exemple de la Réunion struct avant d'imprimer l'instance de struct sur la console.

Vous pouvez créer 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, la durée 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 à la date 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é, chronométrer l'activité des utilisateurs et d'autres opérations Web.