Panic, Defer ו-Recover

חלק מהיחידה תכנות מונחה עצמים במסלול ה-GO של Coddy. שיעור 57 מתוך 107.

אף ש-Go מדגישה החזרת שגיאות, יש מצבים שאי אפשר באמת להתאושש מהם. למקרים כאלה, Go מספקת את panic, את defer ואת recover: מנגנון לטיפול בנסיבות חריגות.

panic עוצרת את הביצוע הרגיל באופן מיידי. היא מיועדת לשגיאות תכנות כמו גישה לאינדקס מחוץ לטווח, ולא לשגיאות צפויות כמו קלט משתמש לא תקין:

func MustGetConfig(key string) string {
    value, exists := config[key]
    if !exists {
        panic("missing required config: " + key)
    }
    return value
}

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

func ProcessFile() {
    fmt.Println("Opening file")
    defer fmt.Println("Closing file")
    fmt.Println("Processing...")
    // פלט: Opening file, Processing..., Closing file
}

recover לוכדת panic ומחזירה את הביצוע למצב רגיל. היא פועלת רק בתוך פונקציה דחויה:

func SafeOperation() (err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("recovered from panic: %v", r)
        }
    }()
    
    riskyOperation()
    return nil
}

התבנית הזאת ממירה מצב panic לשגיאה רגילה, וכך מאפשרת לתוכנית שלך להמשיך לפעול. השתמש בה במשורה: העדף להחזיר שגיאות במקרים צפויים של כשל, ושמור את panic/recover למצבים חריגים באמת, כמו מצב פגום או תנאים שאין מהם התאוששות.

אתגר

קל

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

תארגנו את הקוד בשני קבצים:

calculator.go: צרו את לוגיקת החילוק עם התאוששות מ־panic.
ממשו פונקציה בשם Divide שמקבלת שני מספרים שלמים ומפעילה panic עם ההודעה "division by zero" אם המחלק הוא אפס. אחרת, היא מחזירה את תוצאת החילוק כמספר שלם.

ממשו פונקציה בשם SafeDivide שמקבלת שני מספרים שלמים ומחזירה גם תוצאה כמספר שלם וגם שגיאה. הפונקציה צריכה:
- להשתמש ב־defer עם פונקציה אנונימית כדי להתאושש מכל מצב panic
- אם מתבצעת התאוששות מ־panic, להמיר אותו לשגיאה בפורמט "calculation error: [panic message]"
- לקרוא לפונקציה Divide מתוך הפונקציה
- להחזיר את התוצאה ואת nil אם הפעולה הצליחה, או אפס ואת השגיאה אם התבצעה התאוששות מ־panic
main.go: קראו שני מספרים שלמים מהקלט והשתמשו ב־SafeDivide כדי לבצע את החישוב בבטחה. הדגימו גם את defer באמצעות הדפסת הודעות ניקוי בסדר הנכון.
הפונקציה הראשית שלכם צריכה:
- להדפיס Starting calculation בתחילת הפעולה
- להשתמש ב־defer כדי לתזמן הדפסה של Cleanup complete
- להשתמש ב־defer נוסף כדי לתזמן הדפסה של Releasing resources
- לקרוא ל־SafeDivide עם ערכי הקלט
- להדפיס Result: [value] או Error: [error message], בהתאם לתוצאה

הקלטים הבאים יסופקו:

שורה 1: המספר השלם הראשון (המחולק)
שורה 2: המספר השלם השני (המחלק)

זכרו שקריאות שמבוצעות באמצעות defer מתבצעות בסדר הפוך (האחרונה שנכנסה היא הראשונה שיוצאת), ולכן הודעות הניקוי צריכות להופיע בסדר הפוך לסדר שבו תוזמנו.

לדוגמה, עבור 20 ו־4, הפלט שלכם צריך להיות:

Starting calculation
Result: 5
Releasing resources
Cleanup complete

ועבור 10 ו־0, הפלט שלכם צריך להיות:

Starting calculation
Error: calculation error: division by zero
Releasing resources
Cleanup complete

נסו בעצמכם

package main

import (
	"fmt"
)

func main() {
	// קרא את הקלט
	var dividend, divisor int
	fmt.Scanln(&dividend)
	fmt.Scanln(&divisor)

	// הדפס את הודעת הפתיחה
	fmt.Println("Starting calculation")

	// TODO: השתמש ב-defer כדי לתזמן את ההודעה "Cleanup complete"

	// TODO: השתמש ב-defer כדי לתזמן את ההודעה "Releasing resources"
	// זכור: קריאות שנדחו מתבצעות בסדר LIFO (אחרון נכנס, ראשון יוצא)

	// TODO: קרא ל-SafeDivide עם ערכי הקלט

	// TODO: הדפס את "Result: [value]" או את "Error: [error message]"
	// בהתאם לשאלה אם הוחזרה שגיאה
}