עבודה עם תאריך ושעה בחלודה

טיפול בתאריך ושעה הוא היבט מכריע של יישומים רבים, החל מתזמון משימות וניתוח נתונים ועד ביצוע חישובים והבטחת ייצוג נתונים.

ל-Rust יש ספריות ומודולים רבים לעבודה עם תאריכים ושעות. חלודה מספקת מובנה זְמַן ארגז עבור פעולות הקשורות לזמן, וספריית Chrono פועלת יחד עם ספריות Rust רבות אחרות עבור פעולות תאריך ושעה.

תחילת העבודה עם תאריך ושעה בחלודה

Chrono היא ספריית תאריך-שעה לטיפול בתאריכים, שעות, אזורי זמן ומשכי זמן ב- Rust. Chrono מספק תכונות מרובות וממשק API אינטואיטיבי לסוגי תאריך ושעה, אזורי זמן וקיזוז תאריך-שעה, משך ומרווח, ניתוח ועיצוב ועבודה עם לוחות שנה.

Chrono משחק היטב עם ספריות אחרות במערכת האקולוגית של Rust ומשתלב בצורה חלקה עם התקן תכונות ה-I/O של הספרייה המאפשרות לך לקרוא ולכתוב ערכי תאריך ושעה של Chrono מ ואל שונים זרמים.

בנוסף, ל- Chrono יש תמיכה בהמשכת וסיריאליזציה באמצעות ה סרדה ארגז, מה שמקל על העבודה עם סוגי Chrono ב-JSON, YAML ופורמטים אחרים. השילוב של Chrono עם Serde הופך אותו למתאים לפעולות תאריך-שעה תוך כדי בניית יישומי אינטרנט ב- Rust.

אתה יכול להשתמש ב-Chrono כדי לאחזר את המיקום שלך UTC (זמן אוניברסלי מתואם) עבור פעולות רבות כמו המרות.

הוסף הנחיה זו ל- תלות הקטע שלך Cargo.toml קובץ להתקנה ולהשתמש ב- כרונו אַרְגָז:

[תלות]
כרונו = "0.4.24"

לאחר התקנת ה כרונו ארגז, אתה יכול להשתמש כרונו בפרויקט Rust שלך על ידי ייבוא ​​הארגז כך:

להשתמש chrono:: הקדמה::*;

Chrono הוא אחד מארגזי החלודה שתזדקק להם בארסנל הפיתוח שלך מכיוון שהוא מספק את רוב התכונות לפעולות תאריך ושעה.

אזורי זמן וטיפול בזמן בחלודה עם כרונו

אזורי זמן מבטיחים שחותמות זמן ומידע הקשור לזמן מדויקים ועקביים במיקומים גיאוגרפיים שונים. בזמן עבודה עם נתונים הקשורים לזמן, חיוני לשקול אזורי זמן כדי למנוע אי בהירות ואי דיוקים. פעולות כמו השוואת חותמות זמן, חישוב משכי זמן או תזמון אירועים ללא טיפול נכון באזור זמן עשויות להניב תוצאות בלתי צפויות.

אתה יכול להמיר בין אזורי זמן עם Chrono. הנה דוגמה להמרת א תאריך שעה מאזור זמן אחד לאחר:

להשתמש chrono::{DateTime, Utc, Local, TimeZone};
fnconvert_timezone() {
לתת utc_time: DateTime = Utc:: now();
לתת local_time: DateTime = utc_time.with_timezone(&Local);
println!("זמן UTC: {}", utc_time);
println!("זמן מקומי: {}", זמן מקומי);
}

ה convert_timezone הפונקציה מאחזרת את ה-UTC הנוכחי עם Utc:: עכשיו שיטה, ממירה את ה-UTC לאזור הזמן המקומי עם ה- with_timezone שיטה המתייחסת ל- מְקוֹמִי struct ומחזיר א תאריך שעה אובייקט המייצג את אותה נקודת זמן אך באזור הזמן המקומי.

כשאתה מתקשר ל convert_timezone פונקציה, הוא ידפיס את ה-UTC והזמן המקומי לקונסולה.

בנוסף, Chrono מספקת שיטות ופונקציונליות נוחות עבור שעון קיץ (DST) וקיזוז אזורי זמן. במערכת שלך, אתה יכול כוונן את השעון לשעון קיץ דרך אפליקציית ההגדרות או לוח הבקרה.

הנה דוגמה המציגה את היכולות של Chrono עם DST וקיזוז זמן:

להשתמש chrono::{DateTime, Utc, FixedOffset};
fnhandle_dst() {
לתת utc_time: DateTime = Utc:: now();
לתת ny_timezone = FixedOffset:: east(5 * 3600); 
// שעון קיץ מזרחי (EDT) UTC-4:00 
לתת ny_time: DateTime = utc_time.with_timezone(&ny_timezone);
println!("זמן UTC: {}", utc_time);
println!("שעון ניו יורק: {}", זמן ניו - יורק);
}

ה handle_dst הפונקציה ניגשת לשעה הנוכחית באמצעות עַכשָׁיו שיטה ומחזירה את הזמן בניו יורק תוך התחשבות בזמן הקיזוז עם FixedOffset:: מזרח שיטה.

על ידי התקשרות ל with_timezone פונקציה, אתה ממיר את ה-UTC לאזור הזמן של ניו יורק. Chrono מטפל בהתאמות הזמן בהתאם ל-DST המתאים ומחזיר א תאריך שעה לְהִתְנַגֵד.

כאשר פועלים עם DST, חשוב לזכור שמעברי DST מתרחשים בתאריכים ובשעות ספציפיים. של כרונו תאריך שעה struct מצויד לטפל במעברים אלו ולהבטיח ייצוגים מדויקים של זמן באזורי זמן שונים.

חישובי משך ומרווחים

משך זמן הוא זמן בלתי תלוי בכל נקודת זמן מסוימת. ייתכן שיהיה עליך לחשב את משך הזמן בין שני אירועים, למדוד את הזמן שחלף, או להוסיף או להחסיר כמות מסוימת מזמן מוגדר.

הספרייה הסטנדרטית של Rust זְמַן ארגז מספק כלים מקיפים לטיפול יעיל במשכי זמן.

הנה איך אתה יכול למדוד את זמן הביצוע של פונקציה עם זְמַן אַרְגָז:

להשתמש chrono::{DateTime, Utc};
להשתמש std:: time:: מיידי;
fnרָאשִׁי() {
לתת start = Instant:: now();
// בצע פעולה כלשהי
// ...
לתת end = Instant:: now();
לתת duration = end.duration_since (התחלה);
println!("זמן שחלף: {:?}", משך זמן);
}

ה רָאשִׁי הפונקציה מאחזרת את השעה הנוכחית עם רֶגַע שיטת המובנה זְמַן אַרְגָז. לאחר הניתוח, ה רָאשִׁי הפונקציה מאחזרת את השעה באותו רגע ומעריכה את ההבדל עם duration_since פונקציה לפני הדפסת הפרש הזמן לקונסולה.

המרת תאריך ושעה של JSON למבני חלודה באמצעות Chrono

הסדרת וביטול סדרה של ערכי תאריך ושעה מ-JSON באמצעות Chrono ו-Serde הוא תהליך פשוט. ראשית, הוסף את serde ו serde_json ארגזים לתלות של הפרויקט שלך.

[תלות]
serde = { גרסה = "1.0", תכונות = ["לְהָפִיק"] }
serde_json = "1.0"

לאחר מכן, תצטרך להגדיר את סוג Rust וליישם את #[נגזר (סידרה, ביטול סדרה)] תכונות לסוג שבו תציין את סוג הנתונים:

להשתמש chrono::{DateTime, Utc};
#[נגזר (סידרה, ביטול סדרה)]
structפְּגִישָׁה {
 start_time: DateTime,
 end_time: DateTime,
}

אתה יכול לעשות סדרה של פְּגִישָׁה struct ל-JSON עם Serde לצד יכולות העיצוב של Chrono.

כך תוכל להמיר מופע של ה פְּגִישָׁה הקלד ל-JSON:

להשתמש serde_json:: to_string;
fnרָאשִׁי() {
לתת פגישה = פגישה {
 start_time: Utc:: now(),
 end_time: Utc:: now(),
 };
לתת json = to_string(&meeting).unwrap();
println!("{}", json);
}

ה רָאשִׁי פונקציה יוצרת א פְּגִישָׁה מופע עם UTC הנוכחי עבור השדות לפני השימוש ב- to_string פונקציה להמרת מופע ה-struct למחרוזת JSON המודפסת למסוף.

אתה יכול לבטל בקלות את נתוני התאריך-שעה של JSON לסוג struct עם serde_json's from_str פונקציה שמקבלת מחרוזת JSON ומחזירה מופע struct.

להשתמש serde_json:: from_str;
fnרָאשִׁי() {
לתת json = r#"{"start_time": "2023-05-28T12:00:00Z", "end_time": "2023-05-28T14:00:00Z"}"#;
לתת פגישה: פגישה = from_str (json).unwrap();
println!("{:#?}", פגישה);
}

ה רָאשִׁי הפונקציה מבטלת את מחרוזת ה-JSON מה- json משתנה לתוך פְּגִישָׁה מופע של ה פְּגִישָׁה struct לפני הדפסת מופע ה-struct למסוף.

אתה יכול לבנות יישומים מתוחכמים עם חלודה

החוסן, קלות השימוש והפונקציונליות הנרחבת של Chrono הופכים אותו לכלי הכרחי לטיפול בתאריכים, שעות, משך ומרווחים של האפליקציות שלך. אתה יכול להבטיח חישובי זמן מדויקים, תזמון יעיל ופעולות אמינות הקשורות לתאריך על ידי מינוף היכולות של Chrono.

מקרה שימוש מרכזי אחד עבור Chrono הוא בבניית יישומי אינטרנט. אתה יכול להשתמש ב-Chrono לרשומות זמן פעילות, תזמון פעילות משתמשים ופעולות אחרות באינטרנט.