Lavorare con data e ora in Rust

La gestione della data e dell'ora è un aspetto cruciale di molte applicazioni, dalla pianificazione delle attività e l'analisi dei dati all'esecuzione di calcoli e alla garanzia della rappresentazione dei dati.

Rust ha molte librerie e moduli per lavorare con date e orari. Rust fornisce un built-in tempo crate per le operazioni relative al tempo e la libreria Chrono interagisce con molte altre librerie di Rust per le operazioni di data e ora.

Iniziare a lavorare con data e ora in Rust

Chrono è una libreria data-ora per la gestione di date, orari, fusi orari e durate in Rust. Chrono offre molteplici funzionalità e un'API intuitiva per tipi di data e ora, fusi orari e offset data-ora, durata e intervallo, analisi e formattazione e utilizzo dei calendari.

Chrono funziona bene con altre librerie nell'ecosistema Rust e si integra perfettamente con lo standard i tratti di I/O della libreria che consentono di leggere e scrivere i valori di data e ora di Chrono da e verso vari flussi.

Inoltre, Chrono supporta la serializzazione e la deserializzazione tramite il Serde crate, semplificando il lavoro con i tipi Chrono in JSON, YAML e altri formati. L'integrazione di Chrono con Serde lo rende adatto per le operazioni data-ora mentre creare applicazioni web in Rust.

Puoi usare Chrono per recuperare la tua posizione UTC (tempo universale coordinato) per numerose operazioni come le conversioni.

Aggiungi questa direttiva al file dipendenze sezione del tuo Cargo.toml file per installare e utilizzare il file crono cassa:

[dipendenze]
crono = "0.4.24"

Dopo aver installato il crono cassa, puoi usare crono nel tuo progetto Rust importando la cassa in questo modo:

utilizzo crono:: preludio::*;

Chrono è una delle casse Rust di cui avrai bisogno nel tuo arsenale di sviluppo poiché fornisce la maggior parte delle funzionalità per le operazioni di data e ora.

Fusi orari e gestione del tempo in ruggine con Chrono

I fusi orari garantiscono che i timestamp e le informazioni relative all'ora siano accurati e coerenti in varie località geografiche. Mentre si lavora con dati relativi all'ora, è essenziale considerare i fusi orari per evitare ambiguità e imprecisioni. Operazioni come il confronto di timestamp, il calcolo delle durate o la pianificazione di eventi senza una corretta gestione del fuso orario possono produrre risultati imprevisti.

Puoi passare da un fuso orario all'altro con Chrono. Ecco un esempio di conversione di a Appuntamento da un fuso orario all'altro:

utilizzo crono::{DateTime, Utc, Local, TimeZone};
fnconvert_timezone() {
permettere utc_time: DataOra = Utc:: ora();
permettere local_time: DataOra = utc_time.with_timezone(&Local);
stampa!("ora UTC: {}", utc_time);
stampa!("Ora locale: {}", ora locale);
}

IL convert_timezone La funzione recupera l'ora UTC corrente con il Utc:: ora metodo, converte l'ora UTC nel fuso orario locale con l'estensione with_timezone metodo che prende in riferimento al Locale struct e restituisce a Appuntamento oggetto che rappresenta lo stesso punto nel tempo ma nel fuso orario locale.

Quando chiami il convert_timezone funzione, stamperà l'UTC e l'ora locale sulla console.

Inoltre, Chrono fornisce metodi e funzionalità convenienti per l'ora legale (DST) e gli offset del fuso orario. Nel tuo sistema, puoi regolare l'orologio per l'ora legale tramite l'app Impostazioni o il Pannello di controllo.

Ecco un esempio che mostra le capacità di Chrono con l'ora legale e le differenze di orario:

utilizzo crono::{DateTime, Utc, FixedOffset};
fnhandle_dst() {
permettere utc_time: DataOra = Utc:: ora();
permettere ny_timezone = FixedOffset:: est(5 * 3600); 
// Ora legale orientale (EDT) UTC-4:00 
permettere ny_time: DataOra = utc_time.with_timezone(&ny_timezone);
stampa!("ora UTC: {}", utc_time);
stampa!("Ora di New York: {}", ny_time);
}

IL handle_dst funzione accede all'ora corrente con il Ora metodo e recupera l'ora di New York tenendo conto dell'offset con il FixedOffset:: est metodo.

Chiamando il with_timezone funzione, stai convertendo l'UTC nel fuso orario di New York. Chrono gestisce le regolazioni dell'ora in base all'ora legale appropriata e restituisce a Appuntamento oggetto.

Quando si opera con l'ora legale, è fondamentale ricordare che le transizioni dell'ora legale si verificano in date e orari specifici. di Crono Appuntamento struct è attrezzato per gestire queste transizioni e garantire rappresentazioni accurate del tempo in diversi fusi orari.

Calcoli di durata e intervallo

Una durata è un tempo indipendente da qualsiasi momento specifico. Potrebbe essere necessario calcolare la durata tra due eventi, misurare il tempo trascorso o aggiungere o sottrarre una certa quantità da un tempo specificato.

La libreria standard di Rust tempo crate fornisce strumenti completi per gestire in modo efficiente le durate.

Ecco come puoi misurare il tempo di esecuzione di una funzione con il tempo cassa:

utilizzo crono::{DateTime, Utc};
utilizzo std:: tempo:: istantaneo;
fnprincipale() {
permettere start = Istantaneo:: now();
// Esegue un'operazione
// ...
permettere end = Istante:: now();
permettere durata = fine.durata_since (inizio);
stampa!("Tempo trascorso: {:?}", durata);
}

IL principale funzione recupera l'ora corrente con il Immediato metodo del built-in tempo cassa. Dopo l'operazione, il principale La funzione recupera l'ora in quell'istante e valuta la differenza con il durata_da allora funzione prima di stampare la differenza di orario sulla console.

Serializzazione e deserializzazione: conversione di data e ora JSON in strutture Rust utilizzando Chrono

La serializzazione e deserializzazione dei valori di data e ora da JSON utilizzando Chrono e Serde è un processo semplice. Innanzitutto, aggiungi il serde E serde_json casse alle dipendenze del tuo progetto.

[dipendenze]
serde = { versione = "1.0", caratteristiche = ["derivare"] }
serde_json = "1.0"

Successivamente, dovrai definire il tipo Rust e implementare il file #[derive (Serializza, Deserializza)] attributi per il tipo in cui specificherai il tipo di dati:

utilizzo crono::{DateTime, Utc};
#[derive (Serializza, Deserializza)]
structIncontro {
 start_time: DataOra,
 end_time: DataOra,
}

Puoi serializzare il file Incontro struct a JSON con Serde insieme alle capacità di formattazione di Chrono.

Ecco come convertire un'istanza di Incontro digita in JSON:

utilizzo serde_json:: to_string;
fnprincipale() {
permettere riunione = riunione {
 start_time: Utc:: ora(),
 ora_fine: Utc:: ora(),
 };
permettere json = to_string(&meeting).unwrap();
stampa!("{}", json);
}

IL principale la funzione crea a Incontro istanza con l'ora UTC corrente per i campi prima di utilizzare il accordare funzione per convertire l'istanza struct in una stringa JSON stampata sulla console.

Puoi facilmente deserializzare i dati data-ora JSON in un tipo struct con serde_json da_str funzione che accetta una stringa JSON e restituisce un'istanza struct.

utilizzo serde_json:: from_str;
fnprincipale() {
permettere json = r#"{"start_time": "2023-05-28T12:00:00Z", "end_time": "2023-05-28T14:00:00Z"}"#;
permettere riunione: riunione = from_str (json).unwrap();
stampa!("{:#?}", incontro);
}

IL principale La funzione deserializza la stringa JSON dal file json variabile nella incontro istanza del Incontro struct prima di stampare l'istanza struct nella console.

Puoi creare applicazioni sofisticate con Rust

La robustezza, la facilità d'uso e le ampie funzionalità di Chrono lo rendono uno strumento indispensabile per gestire date, orari, durata e intervalli delle tue app. Puoi garantire calcoli temporali accurati, una pianificazione efficiente e operazioni affidabili relative alla data sfruttando le capacità di Chrono.

Un caso d'uso chiave per Chrono è la creazione di applicazioni web. Puoi utilizzare Chrono per i record del tempo di attività, cronometrare l'attività dell'utente e altre operazioni web.