Praca z datą i czasem w Rust

Obsługa daty i czasu jest kluczowym aspektem wielu aplikacji, od planowania zadań i analizowania danych po wykonywanie obliczeń i zapewnianie reprezentacji danych.

Rust ma wiele bibliotek i modułów do pracy z datami i czasami. Rust zapewnia wbudowane czas crate dla operacji związanych z czasem, a biblioteka Chrono współpracuje z wieloma innymi bibliotekami Rust dla operacji na datach i godzinach.

Rozpoczęcie pracy z datą i godziną w Rust

Chrono to biblioteka daty i czasu do obsługi dat, godzin, stref czasowych i czasu trwania w Rust. Chrono zapewnia wiele funkcji i intuicyjny interfejs API dla typów dat i godzin, stref czasowych i przesunięcia daty i godziny, czasu trwania i interwału, analizowania i formatowania oraz pracy z kalendarzami.

Chrono dobrze współpracuje z innymi bibliotekami w ekosystemie Rust i bezproblemowo integruje się ze standardem cechy I/O biblioteki, umożliwiające odczytywanie i zapisywanie wartości daty i czasu Chrono zi do różnych strumienie.

Ponadto Chrono obsługuje serializację i deserializację za pośrednictwem Serde crate, ułatwiając pracę z typami Chrono w formatach JSON, YAML i innych. Integracja Chrono z Serde sprawia, że ​​nadaje się do operacji na datach i godzinach while tworzenie aplikacji internetowych w języku Rust.

Możesz użyć Chrono, aby odzyskać swoją lokalizację UTC (uniwersalny czas koordynowany) dla wielu operacji, takich jak konwersje.

Dodaj tę dyrektywę do pliku zależności sekcja twojego Cargo.toml plik do zainstalowania i używania chrono skrzynia:

[zależności]
chrono = "0.4.24"

Po zainstalowaniu chrono skrzynia, możesz użyć chrono w swoim projekcie Rust, importując skrzynkę w następujący sposób:

używać chrono:: preludium::*;

Chrono jest jedną ze skrzynek Rust, których będziesz potrzebować w swoim arsenale programistycznym, ponieważ zapewnia większość funkcji związanych z operacjami daty i czasu.

Strefy czasowe i obsługa czasu w Rust z Chrono

Strefy czasowe zapewniają, że znaczniki czasu i informacje związane z czasem są dokładne i spójne w różnych lokalizacjach geograficznych. Podczas pracy z danymi związanymi z czasem ważne jest uwzględnienie stref czasowych, aby uniknąć niejasności i nieścisłości. Operacje takie jak porównywanie sygnatur czasowych, obliczanie czasu trwania lub planowanie wydarzeń bez odpowiedniej obsługi stref czasowych mogą przynieść nieoczekiwane rezultaty.

Możesz konwertować strefy czasowe za pomocą Chrono. Oto przykład konwersji pliku a DataGodzina z jednej strefy czasowej do drugiej:

używać chrono::{DateTime, Utc, Local, TimeZone};
przypstrefa_czasowa konwersji() {
pozwalać utc_time: DataCzas = Utc:: teraz();
pozwalać czas_lokalny: data i godzina = utc_time.with_timezone(&Local);
drukuj!(„Czas UTC: {}”, utc_time);
drukuj!("Czas lokalny: {}", czas lokalny);
}

The strefa_czasowa konwersji funkcja pobiera bieżący czas UTC z rozszerzeniem Utc:: teraz metoda, konwertuje UTC na lokalną strefę czasową za pomocą with_timezone metoda, która przyjmuje w odniesieniu do Lokalny struct i zwraca a DataGodzina obiekt reprezentujący ten sam punkt w czasie, ale w lokalnej strefie czasowej.

Kiedy zadzwonisz do strefa_czasowa konwersji funkcja, wyświetli UTC i czas lokalny na konsoli.

Dodatkowo Chrono zapewnia wygodne metody i funkcje dla czasu letniego (DST) i przesunięć stref czasowych. W twoim systemie możesz ustawić zegar na czas letni poprzez aplikację Ustawienia lub Panel sterowania.

Oto przykład pokazujący możliwości Chrono z przesunięciem czasu letniego i czasowego:

używać chrono::{DateTime, Utc, FixedOffset};
przypuchwyt_dst() {
pozwalać utc_time: DataCzas = Utc:: teraz();
pozwalać ny_timezone = FixedOffset:: wschód(5 * 3600); 
// Wschodni czas letni (EDT) UTC-4:00 
pozwalać ny_time: DataCzas = utc_time.with_timezone(&ny_timezone);
drukuj!(„Czas UTC: {}”, utc_time);
drukuj!(„Czas nowojorski: {}”, Strefa czasowa Nowego Jorku);
}

The uchwyt_dst funkcja uzyskuje dostęp do bieżącego czasu za pomocą Teraz metoda i pobiera czas w Nowym Jorku, uwzględniając czas przesunięcia za pomocą metody FixedOffset:: wschód metoda.

Dzwoniąc do with_timezone funkcji, konwertujesz czas UTC na strefę czasową Nowego Jorku. Chrono obsługuje korekty czasu zgodnie z odpowiednim DST i zwraca a DataGodzina obiekt.

Podczas pracy z DST należy pamiętać, że przejścia na czas letni następują w określonych dniach i godzinach. Chrono DataGodzina struct jest przystosowany do obsługi tych przejść i zapewnia dokładne odwzorowanie czasu w różnych strefach czasowych.

Obliczenia czasu trwania i interwału

Czas trwania to czas niezależny od określonego punktu w czasie. Może być konieczne obliczenie czasu trwania między dwoma zdarzeniami, zmierzenie czasu, który upłynął, albo dodanie lub odjęcie określonej kwoty od określonego czasu.

Standardowa biblioteka Rusta czas crate zapewnia kompleksowe narzędzia do wydajnej obsługi czasów trwania.

Oto jak możesz zmierzyć czas wykonania funkcji za pomocą czas skrzynia:

używać chrono::{DateTime, Utc};
używać std:: czas:: Natychmiast;
przypgłówny() {
pozwalać start = natychmiast:: teraz();
// Wykonaj jakąś operację
// ...
pozwalać koniec = Natychmiast:: teraz();
pozwalać czas trwania = koniec.czas trwania_od (początek);
drukuj!(„Czas, który upłynął: {:?}”, czas trwania);
}

The główny funkcja pobiera bieżący czas za pomocą Natychmiastowy metoda wbudowanej czas skrzynia. Po operacji tzw główny funkcja pobiera czas w tej chwili i ocenia różnicę z czas trwania_od przed wydrukowaniem różnicy czasu na konsoli.

Serializacja i deserializacja: konwertowanie daty i godziny JSON na struktury rdzy za pomocą Chrono

Serializacja i deserializacja wartości daty i godziny z JSON przy użyciu Chrono i Serde to prosty proces. Najpierw dodaj tzw serdeczny I serde_json skrzynek do zależności twojego projektu.

[zależności]
serdeczny = { wersja = "1.0", funkcje = ["czerpać"] }
serde_json = "1.0"

Następnie musisz zdefiniować typ Rusta i zaimplementować #[pochodna (serializacja, deserializacja)] atrybuty dla typu, w których określisz typ danych:

używać chrono::{DateTime, Utc};
#[pochodna (serializacja, deserializacja)]
strukturaSpotkanie {
 godzina_początkowa: DataCzas,
 czas_zakończenia: DataCzas,
}

Możesz serializować Spotkanie struct do JSON z Serde wraz z możliwościami formatowania Chrono.

Oto jak możesz przekonwertować instancję pliku Spotkanie wpisz do JSON:

używać serde_json:: do_ciągu;
przypgłówny() {
pozwalać spotkanie = spotkanie {
 start_time: Utc:: teraz(),
 czas_końcowy: Utc:: teraz(),
 };
pozwalać json = to_string(&spotkanie).unwrap();
drukuj!("{}", json);
}

The główny funkcja tworzy a Spotkanie wystąpienie z bieżącym UTC dla pól przed użyciem do_ciągu funkcję konwertującą instancję struct na ciąg znaków JSON wydrukowany w konsoli.

Możesz łatwo deserializować dane daty i godziny JSON do typu struktury za pomocą serde_json's z_str funkcja, która pobiera ciąg znaków JSON i zwraca instancję struktury.

używać serde_json:: from_str;
przypgłówny() {
pozwalać json = r#"{"start_time": "2023-05-28T12:00:00Z", "end_time": "2023-05-28T14:00:00Z"}"#;
pozwalać spotkanie: Spotkanie = from_str (json).unwrap();
drukuj!("{:#?}", spotkanie);
}

The główny funkcja deserializuje łańcuch JSON z pliku json zmienna w spotkanie instancja Spotkanie struct przed wydrukowaniem instancji struct do konsoli.

Możesz tworzyć zaawansowane aplikacje za pomocą Rust

Solidność Chrono, łatwość obsługi i rozbudowana funkcjonalność sprawiają, że jest to niezbędne narzędzie do obsługi dat, godzin, czasu trwania i interwałów aplikacji. Możesz zapewnić dokładne obliczenia czasu, wydajne planowanie i niezawodne operacje związane z datami, wykorzystując możliwości Chrono.

Jednym z kluczowych przypadków użycia Chrono jest tworzenie aplikacji internetowych. Możesz używać Chrono do rejestrowania czasu aktywności, pomiaru czasu aktywności użytkownika i innych operacji internetowych.