טיפול בשגיאות ב-Go באמצעות חבילת השגיאות

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

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

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

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

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

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

אתה יכול לייבא את

שגיאות חבילה עם מילת המפתח ייבוא. כל שעליך לעשות הוא לציין את שם החבילה ברשימת הייבוא ​​שלך.

יְבוּא"שגיאות"

תפיסה וטיפול בשגיאות ב-Go

ידע בטיפול בסיסי בשגיאות ב-Go מניח את הבסיס להבנת ה שגיאות חֲבִילָה. פונקציות ושיטות מחזירות שגיאות המלוות במשאב.

הנה דוגמה לטיפול בשגיאות מפעולת פתיחת קובץ עם המובנה OS חֲבִילָה.

חֲבִילָה רָאשִׁי
יְבוּא (
"fmt"
"os"
)
funcרָאשִׁי() {
 קובץ, שגיאה := os. לִפְתוֹחַ("filename.txt")
אם טעות != אֶפֶס {
 fmt. Println (שגיאה)
 }
// ...
}

ה לִפְתוֹחַ שיטת ה OS החבילה שימושית כאשר עבודה עם קבצי טקסט ב-Go. זה פותח קובץ, מחזיר מופע קובץ פתוח ו-an שְׁגִיאָה.

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

אתה יכול לגשת ל שְׁגִיאָה שיטת שגיאה כדי לחלץ מידע נוסף על השגיאה (בדרך כלל תיאור).

אם טעות != אֶפֶס {
 fmt. Println (שגיאה. שְׁגִיאָה())
}

לדוגמה, אם הקובץ לא קיים, תראה הודעת שגיאה שנראית בערך כך:

יצירת שגיאות ב-Go

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

יְבוּא"שגיאות"
funcרָאשִׁי() {
 שגיאה := שגיאות. חָדָשׁ("משהו השתבש")
אם טעות != אֶפֶס {
// קוד טיפול בשגיאות נכנס לכאן
 }
}

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

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

חֲבִילָה רָאשִׁי
יְבוּא"fmt"
סוּג customError struct {
 מידע חוּט
}
funcרָאשִׁי() {
// דוגמה למופע של המבנה
 error := customError{
 מידע: "משהו השתבש!",
 }
// פלט את המופע של המבנה
 fmt. Println (שגיאה)
}

ה customError struct הוא התוכנית לשגיאה, וה- מידע שדה המחרוזת יכיל את הודעת השגיאה.

פונקציות השגיאה שלך יכולות ליישם את customError struct והחזר מחרוזת שגיאה.

func(ce customError)שְׁגִיאָה()חוּט {
לַחֲזוֹר fmt. ספרינטף("אירעה שגיאה מותאמת אישית: %v", ce.info)
}

ה שְׁגִיאָה שיטת ה customError struct מחזיר מחרוזת באמצעות שיטת העיצוב Sprintf של חבילת fmt.

שגיאות גלישה וביטול גלישה ב-Go

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

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

יְבוּא (
"fmt"
"os"
)
funcרָאשִׁי() {
 _, טעות := os. לִפְתוֹחַ("filename.txt")
אם טעות != אֶפֶס {
 wrappedErr := fmt. שגיאה("שגיאה בפתיחת קובץ: %v", טעות)
 fmt. Println (wrappedErr)
 }
}

ה רָאשִׁי הפונקציה פותחת קובץ עם ה- OS של החבילה לִפְתוֹחַ שיטה ועוטפת את השגיאה בשיטת Errof של fmt חֲבִילָה. לאחר מכן הוא מוציא את השגיאה העטופה לקונסולה.

אתה יכול לבטל שגיאות עטופות בתוכניות שלך עם לְגוֹלֵל שיטת ה שגיאות חֲבִילָה. ה לְגוֹלֵל השיטה לוקחת את השגיאה העטופה ומחזירה את השגיאה הלא עטופה.

יְבוּא (
"fmt"
"os"
"שגיאות"
)
funcרָאשִׁי() {
 _, טעות := os. לִפְתוֹחַ("filename.txt")
אם טעות != אֶפֶס {
 wrappedErr := fmt. שגיאה("שגיאה בפתיחת קובץ: %v", טעות)
 unwrappedErr := שגיאות. סר עטיפה (wrappedErr)
 fmt. Println (unwrappedErr)
 }
}

ה רָאשִׁי function עוטפת שגיאה מפעולת פתיחת קובץ, וה- unwrappedErr המשתנה מחזיק את השגיאה הבלתי עטופה.

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

תצטרך לרשום כמה שגיאות עבור סקירות מאוחרות יותר, איתור באגים ופעולות אחרות במהלך תהליך פיתוח האפליקציה שלך. אתה יכול להשתמש ב זאפ חבילה של Uber, Logrus, Zerolog ו-Log15 לרישום מהיר ומובנה.