טיפול בשגיאות בחלודה עם גישות שונות

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

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

סוגי השגיאות בחלודה

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

להלן רשימה של סוגי שגיאות נפוצים ב- Rust:

• ה std:: io:: שגיאה סוג מייצג שגיאות קלט/פלט כגון קובץ לא נמצא, הרשאה נדחתה או שהגעת לסוף הקובץ.
• ה std:: num:: ParseIntError type מייצג שגיאות המתרחשות פעולות ניתוח מחרוזת למספר שלם.
instagram viewer
• ה std:: option:: NoneError סוג מייצג שגיאות מפירוק אפשרויות ריקות.
• ה std:: תוצאה:: תוצאה type הוא סוג תוצאה כללי שבו אתה יכול להשתמש כדי לייצג כל שגיאה.

לכל סוג שגיאה יש מערכת משלו של שיטות ותכונות לטיפול בה בדרכים ספציפיות.

הנה דוגמה לטיפול בשגיאות ב- Rust עבור פעולת קריאת קבצים:

להשתמש std:: fs:: קובץ;
להשתמש std:: io:: קרא;
fnread_file(נתיב: &str) -> תוֹצָאָה<חוּט, std:: io:: Error> {
לתתמוט file = File:: open (נתיב)?;
לתתמוט תוכן = חוּט::חָדָשׁ();
 file.read_to_string(&מוט תוכן)?;
בסדר(תוכן)
}

ה read_file הפונקציה קוראת את תוכן הקובץ בנתיב שצוין ומחזירה אותו כמחרוזת. זה מחזיר א std:: io:: שגיאה אם פעולת פתיחת הקובץ או הקריאה נכשלת. ה ? אופרטור מפיץ את השגיאה ומחזיר את השגיאה בתור a תוֹצָאָה.

מנגנוני טיפול בשגיאות בחלודה

מאפיין מרכזי אחד שתורם לבטיחות של Rust הוא מנגנוני הטיפול בשגיאות. ישנם ארבעה מנגנוני טיפול עיקריים בשגיאות ב-Rust: ה תוֹצָאָה הקלד את ה אוֹפְּצִיָה הקלד את ה בהלה! מאקרו, וה- שְׁגִיאָה תְכוּנָה.

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

סוג התוצאה

ה תוֹצָאָה סוג הוא סוג מובנה המייצג את התוצאה של פעולה שעלולה להיכשל. יש לו שתי גרסאות: ה בסדר וריאנט, המייצג הצלחה ומכיל ערך, ו לִטְעוֹת, המייצג כשל ומכיל ערך שגיאה.

כך תוכל להשתמש בסוג התוצאה כדי לפתוח קובץ ולקרוא את תוכנו:

להשתמש std:: fs:: קובץ;
להשתמש std:: io:: prelude::*;
fnread_file(קובץ_נתיב: &str) -> תוֹצָאָה<חוּט, std:: io:: Error> {
לתתמוט file = File:: open (file_path)?;
לתתמוט תוכן = חוּט::חָדָשׁ();
 file.read_to_string(&מוט תוכן)?;
בסדר(תוכן)
}
fnרָאשִׁי() {
לתת תוצאה = read_file("file.txt");
התאמה תוצאה {
בסדר(תוכן) => println!("{}", תוכן),
לִטְעוֹת(ה) => println!("שגיאה: {}",ה),
 }
}

ה read_file הפונקציה לוקחת את נתיב הקובץ ומחזירה את a תוֹצָאָה שְׁגִיאָה. אם פעולת הקריאה או הפתיחה של הקובץ נכשלת, הפונקציה מחזירה את לִטְעוֹת ערך. אחרת, הפונקציה מחזירה את בסדר ערך. בתוך ה רָאשִׁי פונקציה, ה התאמה הצהרה מטפלת ב תוֹצָאָה value ומדפיס את התוצאה בהתאם למצב פעולת הקובץ.

סוג האופציה

ה אוֹפְּצִיָה סוג הוא סוג מובנה המייצג נוכחות או היעדרות של ערך. ה אוֹפְּצִיָה לסוג יש שתי גרסאות. כמה מייצג ערך, ו אף אחד מייצג את היעדר ערך.

הנה איך אתה יכול להשתמש ב- אוֹפְּצִיָה הקלד כדי לאחזר את האלמנט הראשון של וקטור.

fnget_first_elementשיבוט>(vec: Vec) -> אוֹפְּצִיָה {
אם vec.is_empty() {
אף אחד
 } אַחֵר {
כמה(vec.first().unwrap().clone())
 }
}
fnרָאשִׁי() {
לתת vec = vec![1, 2, 3];
לתת תוצאה = get_first_element (vec);
התאמה תוצאה {
כמה(אלמנט) => println!("{}", אלמנט),
אף אחד => println!("הווקטור ריק."),
 }
}

ה get_first_element הפונקציה מחזירה את an אוֹפְּצִיָה סוּג. אם הווקטור ריק, הפונקציה מחזירה אף אחד; אחרת, הפונקציה מחזירה כמה המכיל את האלמנט הראשון של הווקטור. בתוך ה רָאשִׁי פונקציה, ה התאמה הצהרה מטפלת ב אוֹפְּצִיָה ערך. אם ה אוֹפְּצִיָה מעריך ל כמה, הפונקציה מדפיסה את האלמנט הראשון. אחרת, הפונקציה מדפיסה הודעה המציינת שהווקטור ריק.

הפאניקה! מאקרו

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

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

fnלחלק(דיבידנד: f64, מחלק: f64) -> f64 {
אם מחלק == 0.0 {
בהלה!("המחלק לא יכול להיות אפס.");
 }
 דיבידנד / מחלק
}
fnרָאשִׁי() {
לתת תוצאה = חלק(4.0, 0.0);
println!("{}", תוצאה);
}

ה לחלק הפונקציה בודקת אם המחלק הוא אפס; אם המחלק הוא אפס, הפונקציה קוראת ל- בהלה! מאקרו עם הודעת שגיאה; אחרת, הפונקציה מחשבת ומחזירה את התוצאה

ה רָאשִׁי function קוראת לפונקציית divide עם ארגומנטים לא חוקיים כדי להפעיל את בהלה! מאקרו.

הנה הודעת השגיאה:

תכונת השגיאה

ה שְׁגִיאָה תכונה היא תכונה מובנית המגדירה את ההתנהגות של סוגי שגיאות. ה שְׁגִיאָה trait מספק פונקציונליות להגדרת סוגי שגיאות מותאמים אישית וטיפול בשגיאות מותאם אישית.

הנה דוגמה להגדרת סוג שגיאה מותאם אישית המייצג שגיאה של קובץ לא נמצא.

להשתמש std:: error:: שגיאה;
להשתמש std:: fmt;
להשתמש std:: io:: קרא;
#[נגזר (ניפוי באגים)]
structהקובץ לא נמצא(חוּט);
impl fmt:: תצוגה ל הקובץ לא נמצא {
fnfmt(&עצמי,f: &מוט fmt:: פורמט) -> fmt::תוֹצָאָה {
לִכתוֹב!(ו, "הקובץ לא נמצא: {}", עצמי.0)
 }
}
impl שְׁגִיאָה ל הקובץ לא נמצא {}
fnread_file(קובץ_נתיב: &str) -> תוֹצָאָה<חוּט, קופסא<dyn שגיאה >> {
לתתמוט file = std:: fs:: File:: open (file_path).map_err(|e| FileNotFound(פוּרמָט!("{}", ה)))?;
לתתמוט תוכן = חוּט::חָדָשׁ();
 file.read_to_string(&מוט תוכן)?;
בסדר(תוכן)
}
fnרָאשִׁי() {
לתת תוצאה = read_file("file.txt");
התאמה תוצאה {
בסדר(תוכן) => println!("{}", תוכן),
לִטְעוֹת(ה) => println!("שגיאה: {}",ה),
 }
}

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

בתוך ה read_file פונקציה, ה הקובץ לא נמצא סוג השגיאה מייצג שגיאה של קובץ לא נמצא, וה- map_err השיטה ממירה את השגיאה std:: io:: לשגיאה של FileNotFound. סוף כל סוף, התיבה type מאפשר לפונקציה להחזיר כל סוג שמיישם את תכונת השגיאה.

ה רָאשִׁי הפונקציה קוראת ל- read_file פונקציה עם נתיב הקובץ, ואם הוא מוצא את הקובץ, מדפיס את תוכנו למסוף. אחרת, הוא מדפיס את הודעת השגיאה.

להלן התוצאה עבור קובץ שאינו קיים:

אתה יכול להתבסס על מודל הבעלות של Rust לבטיחות התוכנית

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

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