Apgūstiet svarīgākos jēdzienus, kā savos Rust projektos manipulēt ar datumiem un laikiem.

Datuma un laika apstrāde ir būtisks daudzu lietojumprogrammu aspekts, sākot no uzdevumu plānošanas un datu analīzes līdz aprēķinu veikšanai un datu attēlojuma nodrošināšanai.

Rust ir daudz bibliotēku un moduļu darbam ar datumiem un laikiem. Rūsa nodrošina iebūvētu laiks kaste ar laiku saistītām darbībām, un Chrono bibliotēka sadarbojas ar daudzām citām Rust bibliotēkām datuma un laika darbībām.

Darba sākšana ar datumu un laiku rūsā

Chrono ir datuma un laika bibliotēka datumu, laiku, laika joslu un ilgumu apstrādei programmā Rust. Chrono nodrošina vairākas funkcijas un intuitīvu API datuma un laika veidiem, laika zonām un datuma laika nobīdei, ilgumam un intervālam, parsēšanai un formatēšanai, kā arī darbam ar kalendāriem.

Chrono labi darbojas ar citām Rust ekosistēmas bibliotēkām un nemanāmi integrējas ar standartu bibliotēkas I/O iezīmes, kas ļauj lasīt un rakstīt Chrono datuma un laika vērtības no un uz dažādām straumes.

instagram viewer

Turklāt Chrono atbalsta serializāciju un deserializāciju, izmantojot Serde kaste, atvieglojot darbu ar Chrono tipiem JSON, YAML un citos formātos. Chrono integrācija ar Serde padara to piemērotu datuma un laika operācijām tīmekļa lietojumprogrammu veidošana Rustā.

Varat izmantot Chrono, lai izgūtu savu atrašanās vietu UTC (koordinētais universālais laiks) daudzām darbībām, piemēram, konvertēšanai.

Pievienojiet šo direktīvu atkarības jūsu sadaļa Krava.toml failu, lai instalētu un izmantotu chrono kaste:

[atkarības]
chrono = "0.4.24"

Pēc instalēšanas chrono kaste, varat izmantot chrono savā Rust projektā, importējot kasti šādi:

izmantot hrono:: prelūdija::*;

Chrono ir viena no Rust kastēm, kas jums būs nepieciešamas jūsu izstrādes arsenālā, jo tā nodrošina lielāko daļu datuma un laika darbību funkciju.

Laika joslas un laika apstrāde Rust With Chrono

Laika joslas nodrošina, ka laikspiedoli un ar laiku saistītā informācija ir precīza un konsekventa dažādās ģeogrāfiskās vietās. Strādājot ar datiem, kas saistīti ar laiku, ir svarīgi ņemt vērā laika joslas, lai novērstu neskaidrības un neprecizitātes. Tādas darbības kā laikspiedolu salīdzināšana, ilguma aprēķināšana vai notikumu plānošana bez atbilstošas ​​laika joslas apstrādes var dot negaidītus rezultātus.

Izmantojot Chrono, varat konvertēt starp laika joslām. Šeit ir a konvertēšanas piemērs Datums Laiks no vienas laika joslas uz citu:

izmantot chrono::{DateTime, Utc, Local, TimeZone};
fnconvert_timezone() {
ļaut utc_time: Datums un laiks = Utc:: now();
ļaut local_time: DateTime = utc_time.with_timezone(&Local);
println!("UTC laiks: {}", utc_time);
println!("Vietējais laiks: {}", vietējais laiks);
}

The convert_timezone funkcija izgūst pašreizējo UTC ar Utc:: tagad metodi, konvertē UTC uz vietējo laika joslu, izmantojot ar_laika joslu metode, kas atsaucas uz Vietējais strukturēt un atgriež a Datums Laiks objekts, kas attēlo to pašu laika punktu, bet vietējā laika joslā.

Kad jūs zvanāt uz convert_timezone funkciju, tas konsolē izdrukās UTC un vietējo laiku.

Turklāt Chrono nodrošina ērtas metodes un funkcijas vasaras laika (DST) un laika joslu nobīdēm. Savā sistēmā jūs varat pielāgot pulksteni vasaras laikam izmantojot lietotni Iestatījumi vai vadības paneli.

Šeit ir piemērs, kas parāda Chrono iespējas ar DST un laika nobīdēm:

izmantot chrono::{DateTime, Utc, FixedOffset};
fnhand_dst() {
ļaut utc_time: Datums un laiks = Utc:: now();
ļaut ny_timezone = Fiksētā nobīde:: austrumi(5 * 3600); 
// Austrumu vasaras laiks (EDT) UTC-4:00 


ļaut ny_time: datums un laiks = utc_time.with_timezone(&ny_timezone);
println!("UTC laiks: {}", utc_time);
println!("Ņujorkas laiks: {}", ny_time);
}

The hand_dst funkcija piekļūst pašreizējam laikam ar tagad metodi un izgūst laiku Ņujorkā, vienlaikus uzskaitot nobīdes laiku ar Fiksētā nobīde:: austrumi metodi.

Zvanot uz ar_laika joslu funkciju, jūs konvertējat UTC uz Ņujorkas laika joslu. Chrono apstrādā laika korekcijas saskaņā ar atbilstošo DST un atgriež a Datums Laiks objektu.

Strādājot ar DST, ir ļoti svarīgi atcerēties, ka DST pārejas notiek noteiktos datumos un laikos. Chrono's Datums Laiks struct ir aprīkots, lai apstrādātu šīs pārejas un nodrošinātu precīzu laika attēlojumu dažādās laika zonās.

Ilguma un intervālu aprēķini

Ilgums ir laiks, kas nav atkarīgs no kāda konkrēta laika punkta. Iespējams, jums būs jāaprēķina ilgums starp diviem notikumiem, jāizmēra pagājušais laiks vai jāpievieno vai jāatņem noteikta summa no noteikta laika.

Rust standarta bibliotēka laiks crate nodrošina visaptverošus rīkus efektīvai apstrādes ilgumam.

Lūk, kā varat izmērīt funkcijas izpildes laiku, izmantojot laiks kaste:

izmantot chrono::{DateTime, Utc};
izmantot std:: laiks:: Tūlītēja;
fngalvenais() {
ļaut start = Instant:: now();


// Veikt kādu darbību
// ...


ļaut beigas = Instant:: now();
ļaut ilgums = beigas.ilgums_kopš (sākums);
println!("Pagājušais laiks: {:?}", ilgums);
}

The galvenais funkcija izgūst pašreizējo laiku ar Tūlītēja iebūvētā metode laiks kaste. Pēc operācijas, galvenais funkcija izgūst laiku šajā brīdī un novērtē atšķirību ar ilgums_kopš funkciju pirms laika starpības drukāšanas konsolē.

Serializēšana un deserializācija: JSON datuma un laika konvertēšana rūsas konstrukcijās, izmantojot Chrono

Datuma un laika vērtību serializēšana un deserializēšana no JSON, izmantojot Chrono un Serde, ir vienkāršs process. Pirmkārt, pievienojiet serde un serde_json kastes jūsu projekta atkarībām.

[atkarības]
serde = { versija = "1.0", funkcijas = ["atvasināt"] }
serde_json = "1.0"

Pēc tam jums būs jādefinē rūsas veids un jāievieš #[atvasināt (serializēt, deserializēt)] atribūti tipam, kurā norādāt datu tipu:

izmantot chrono::{DateTime, Utc};
#[atvasināt (serializēt, deserializēt)]
struktūraTikšanās {
 sākuma_laiks: Datums un laiks,
 beigu_laiks: Datums un laiks,
}

Jūs varat serializēt Tikšanās struct uz JSON ar Serde kopā ar Chrono formatēšanas iespējām.

Tālāk ir norādīts, kā varat konvertēt gadījumu Tikšanās ierakstiet JSON:

izmantot serde_json:: to_string;
fngalvenais() {
ļaut sapulce = tikšanās {
 sākuma_laiks: Utc:: tagad(),
 beigu_laiks: Utc:: tagad(),
 };
ļaut json = to_string(&sapulce).unwrap();
println!("{}", json);
}

The galvenais funkcija rada a Tikšanās gadījumu ar pašreizējo UTC laukiem pirms lietojat to_string funkcija, lai pārveidotu struktūras gadījumu par JSON virkni, kas drukāta konsolē.

Varat viegli deserializēt JSON datuma un laika datus struktūras veidā, izmantojot serde_json from_str funkcija, kas uzņem JSON virkni un atgriež struktūras gadījumu.

izmantot serde_json:: from_str;
fngalvenais() {
ļaut json = r#"{"sākuma_laiks": "2023-05-28T12:00:00Z", "end_time": "2023-05-28T14:00:00Z"}"#;
ļaut sapulce: sapulce = from_str (json).unwrap();
println!("{:#?}", tikšanās);
}

The galvenais funkcija deserializē JSON virkni no json mainīgais tikšanās gadījums Tikšanās struct pirms struct instances drukāšanas konsolē.

Izmantojot rūsu, varat izveidot sarežģītas lietojumprogrammas

Chrono robustums, lietošanas vienkāršība un plašā funkcionalitāte padara to par neaizstājamu rīku, lai apstrādātu jūsu lietotņu datumus, laikus, ilgumu un intervālus. Izmantojot Chrono iespējas, varat nodrošināt precīzus laika aprēķinus, efektīvu plānošanu un uzticamas ar datumu saistītas darbības.

Viens no galvenajiem Chrono lietošanas gadījumiem ir tīmekļa lietojumprogrammu veidošana. Varat izmantot Chrono aktivitāšu laika ierakstiem, lietotāju aktivitāšu laika noteikšanai un citām tīmekļa darbībām.