Go היא שפת תכנות אהובה שגדלה בפופולריות שלה בגלל האפקטיביות, המהירות והיעילות שלה. עם זאת, טעויות יכולות לקרות במהלך שלבי הפיתוח והביצוע, בדיוק כמו בכל שפת תכנות אחרת. טיפול בשגיאות ביעילות חיוני כדי להבטיח את המהימנות והיציבות של תוכניות ה-Go שלך.
מאמר זה יבחן מספר שיטות ונהלים מומלצים לניהול שגיאות ב-Go.
טיפול בשגיאות בגולנג
ב-Go, אתה יכול לטפל בשגיאות באמצעות השיטות המוזכרות להלן:
1: New() פונקציה
שפת Go מספקת את חָדָשׁ() פונקציה לניהול שגיאות. פונקציה זו, הזמינה בחבילת השגיאות המובנית, מאפשרת למפתחים ליצור הודעות שגיאה מותאמות אישית עבור התוכניות שלהם. על ידי שימוש ב חָדָשׁ() פונקציה, מפתחים יכולים לטפל בשגיאות ביעילות ולספק הודעות שגיאה משמעותיות למשתמשים.
החבילה הראשית
יְבוּא 'שגיאות'
יְבוּא 'fmt'
בדיקת תפקוד ( מחרוזת שם ) שְׁגִיאָה {
nError := errors.New ( 'שם לא חוקי' )
אם שֵׁם ! = 'לינוקס' {
לַחֲזוֹר שגיאה
}
לַחֲזוֹר אֶפֶס
}
func main ( ) {
שם := 'לינוקס'
טעות := לבדוק ( שֵׁם )
אם לִטְעוֹת ! = אפס {
fmt.Println ( לִטְעוֹת )
} אַחֵר {
fmt.Println ( 'שם חוקי' )
}
}
הקוד לעיל משתמש ב- חָדָשׁ() checkName פונקציה כדי לראות אם המחרוזת לינוקס תואם את השם שניתן. הפונקציה מייצרת שגיאה בהודעה שם לא חוקי אם השם לא לינוקס . הפונקציה מחזירה אפס כדי להראות שלא הייתה שגיאה אם השם שווה ל לינוקס .
משתנה השם מוגדר ל לינוקס בקריאה של הפונקציה הראשית ל- checkName פונקציה, שגם לוקחת את משתנה השם כארגומנט. הפונקציה הראשית מדפיסה את הודעת השגיאה אם checkName הפונקציה מחזירה שגיאה. הפונקציה הראשית מדפיסה את שם חוקי אם ה checkName הפונקציה מחזירה אפס.
תְפוּקָה
2: Errorf() פונקציה
ה Errorf() function in Go מאפשר לנו לטפל גם בשגיאות. Errorf() נותן לנו את האפשרות לעצב את הודעת השגיאה. על ידי ייבוא חבילת fmt, מפתחים יכולים להשתמש בה כדי להתאים אישית הודעות שגיאה כדי להתאים לצרכים שלהם. Errorf() מייעל ומשפר את היעילות של ניהול והעברת שגיאות ב-Go.
החבילה הראשיתיְבוּא 'fmt'
func div ( n1, n2 אתה ) שְׁגִיאָה {
אם n2 == 0 {
לַחֲזוֹר fmt.Errorf ( '%d / %d \n לא ניתן לחלק מספר באפס' , n1, n2 )
}
לַחֲזוֹר אֶפֶס
}
func main ( ) {
טעות := div ( 42 , 0 )
אם לִטְעוֹת ! = אפס {
fmt.Printf ( 'שגיאה: %s' , טעות )
} אַחֵר {
fmt.Println ( 'חלוקה תקפה' )
}
}
בקוד לעיל, ה div הפונקציה מקבלת שני כניסות שלמים, n1 ו-n2, ואם n2 הוא אפס, היא מייצרת שגיאה. הפונקציה מייצרת שגיאה עם הודעה המכילה את הערכים של n1 ו-n2 אם n2 הוא אפס. הפונקציה מחזירה אפס כדי להראות שלא הייתה שגיאה אם n2 אינו אפס.
השגיאה שמחזירה div נשמרת במשתנה err כאשר הפונקציה הראשית מריצה div עם הערכים 42 ו-0. הפונקציה הראשית משתמשת ב-fmt.Printf כדי להציג את הודעת השגיאה אם הפונקציה div מחזירה שגיאה. הפונקציה העיקרית מדפיסה חלוקה תקפה אם הפונקציה div מחזירה אפס.
תְפוּקָה
3: טיפול בשגיאות מפורש
Go מעודד ניהול שגיאות מפורש בהשוואה לשפות תכנות אחרות, הנשענות לעתים קרובות על חריגים. גישה זו מעודדת מפתחים להשתמש בהצהרות if כדי לבדוק במפורש שגיאות, במקום להסתמך על בלוקים של try-catch. על ידי כך, יש סיכוי גבוה יותר שטעויות יימצאו ויתוקנו כראוי. כדי להקל על זה, Go מספקת את אם טעות != אפס statement, המאפשר למפתחים לבדוק שגיאות לאחר ביצוע פונקציה, ולנקוט פעולות מתאימות על סמך התוצאה. עם טיפול מפורש בשגיאות, Go מציעה גישה מובנית ואמינה יותר לניהול שגיאות.
החבילה הראשיתיְבוּא 'fmt'
חלוקת פונקציות ( a, b float64 ) ( float64, שגיאה ) {
אם b == 0 {
לַחֲזוֹר 0 , fmt.Errorf ( 'לא יכול לחלק באפס' )
}
לַחֲזוֹר א / ב, אפס
}
func main ( ) {
תוצאה, טעות := לחלק ( 13 , 3 )
אם לִטְעוֹת ! = אפס {
fmt.Printf ( 'שגיאה: %v \n ' , טעות )
} אַחֵר {
fmt.Printf ( 'תוצאה: %f \n ' , תוצאה )
}
תוצאה, טעות = לחלק ( 23 , 0 )
אם לִטְעוֹת ! = אפס {
fmt.Printf ( 'שגיאה: %v \n ' , טעות )
} אַחֵר {
fmt.Printf ( 'תוצאה: %f \n ' , תוצאה )
}
}
באיור זה, פונקציית החלוקה משמשת לחלוקת שני ערכים. התפוקה היא התוצאה של ביצוע כך. אם המספר השני הוא 0, הפונקציה מייצרת שגיאה עם הודעת שגיאה ברורה.
חלוקה נקראת פעמיים בפונקציה הראשית: פעם אחת עם קלט חוקי ופעם אחת עם קלט לא חוקי. ה, אם טעות != אפס הצהרה משמשת כדי לקבוע אם התרחשה שגיאה בכל פעם שפונקציית החלוקה מנוצלת. אם מתרחשת הודעת שגיאה מודפסת. אם לא, התוצאה מודפסת.
תְפוּקָה
4: דחה, פאניקה והתאושש
גולנג מספקת גם את לִדחוֹת משפט, המשמש לביצוע פונקציה לאחר השלמת תוכנית או בלוק קוד מסוים. ה לִדחוֹת הצהרה משמשת לעתים קרובות בשילוב עם לְהַחלִים פונקציה לתפוס ולהתאושש משגיאות פאניקה בזמן ריצה. כאשר מתרחשת שגיאת פאניקה בזמן ריצה, ה לְהַחלִים הפונקציה משמשת להתאוששות ממצב השגיאה ולמנוע מהתוכנית לקרוס. זה שימושי למשימות ניקוי כגון סגירת קבצים, סגירת חיבורי רשת או שחרור משאבים. על ידי דחיית משימות אלו, אתה מבטיח שהן יבוצעו גם אם מתרחשת שגיאה.
ה בהלה משמש לעצירת ההפעלה הרגילה של התוכנית כאשר מתרחשת שגיאה בלתי צפויה, while לְהַחלִים משמש לטיפול בפאניקה והמשך ביצוע התוכנית.
החבילה הראשיתיְבוּא 'fmt'
func recoverFromPanic ( ) {
אם r := להתאושש ( ) ; ר ! = אפס {
fmt.Println ( 'התאושש מפאניקה:' ,ר )
}
}
חלוקת פונקציות ( x,y float64 ) לצוף64 {
דחה את ההתאוששותFromPanic ( )
אם ו == 0 {
בהלה ( 'לא יכול לחלק באפס' )
}
לַחֲזוֹר איקס / ו
}
func main ( ) {
fmt.Println ( לחלק ( 13 , 3 ) )
fmt.Println ( לחלק ( 23 , 0 ) )
}
בקוד לעיל, פונקציית החלוקה משמשת לחלוקת שני ערכי נקודה צפה. התפוקה היא התוצאה של ביצוע כך. הודעת שגיאה מותאמת מופקת על ידי הפונקציה אם המספר השני הוא אפס. הצהרת הדחייה משמשת להפעלת ה recoverFromPanic פוּנקצִיָה. ה recoverFromPanic function תזהה פאניקה שהתרחשה בתוך פונקציית החלוקה ותדפיס שגיאה אם היא קרתה.
חלוקה נקראת פעמיים בפונקציה הראשית: פעם אחת עם קלט חוקי ופעם אחת עם קלט לא חוקי. ה fmt.Println function מדפיס את הפלט של הפונקציה בכל פעם שפונקציית החלוקה מופעלת. ה recoverFromPanic הפונקציה תזהה פאניקה אם היא מתרחשת ותדפיס שגיאה אם כן.
תְפוּקָה
לאחר זיהוי השגיאה, התוכנית התאוששה מהבהלה והמשיכה לפעול. עם זאת, הקוד נכנס לפאניקה ולא החזיר ערך בקריאה השנייה לחלוקה, וזו הסיבה שהוא החזיר אפס.
5: שגיאת גלישה
Go כולל גם תכונה המכונה שגיאה בגלישה , המאפשר לך להוסיף הקשר נוסף להודעת שגיאה. זה מועיל להקלטת בעיות או לספק פרטים נוספים בהודעות שגיאה. ניתן להשיג זאת על ידי יצירת סוג שגיאה המטמיע את השגיאה המקורית והקשר נוסף.
החבילה הראשיתיְבוּא 'שגיאות'
יְבוּא 'fmt'
func main ( ) {
אם טעות := בר ( ) ; לִטְעוֹת ! = אפס {
fmt.Println ( לִטְעוֹת )
}
}
חלוקת פונקציות ( a, b float64 ) ( float64, שגיאה ) {
אם b == 0 {
לַחֲזוֹר 0 , שגיאות.חדש ( 'חלוקה באפס' )
}
לַחֲזוֹר א / ב, אפס
}
סרגל func ( ) ( שגיאה ) {
_, טעות = לחלק ( 42 , 0 )
אם לִטְעוֹת ! = אפס {
לַחֲזוֹר fmt.Errorf ( 'לא הצליח לחשב: %w' , טעות )
}
לַחֲזוֹר אֶפֶס
}
בקוד לעיל, פונקציית החלוקה מחשבת את היחס בין שני מספרים בדוגמה זו וזורקת שגיאה אם הערך השני הוא אפס. פונקציית הסרגל קוראת לפונקציית החלוקה ולאחר מכן עוטפת את השגיאה לחלק מחזירה שגיאה חדשה עם הודעה הכוללת את הודעת השגיאה המקורית באמצעות הפונקציה fmt.Errorf. פונקציית הסרגל נקראת על ידי הפונקציה הראשית, אשר גם מדפיסה את כל השגיאות שהיא מחזירה.
תְפוּקָה
סיכום
פיתוח תוכנה חייב לכלול טיפול בשגיאות , ולגולנג יש פונקציות ושיטות מובנות שונות לעשות זאת בחן. מנגנונים אלו מאפשרים למפתחים לתפוס שגיאות ולשחזר אותן, למנוע קריסות של תוכניות ולספק הודעות שגיאה אינפורמטיביות למשתמשי הקצה. על ידי שימוש יעיל במנגנוני טיפול בשגיאות אלה, מפתחים יכולים לבנות יישומי תוכנה חזקים, אמינים ויעילים.