أنماط الأخطاء المتقدمة

أنماط الأخطاء المتقدمة — Advanced Error Patterns

بعد فهم الأساسيات، حان وقت الأنماط المتقدمة. هذه الأنماط تُستخدم في المشاريع الكبيرة حيث تحتاج تصنيف الأخطاء والتعامل مع كل نوع بشكل مختلف.

الأخطاء الحارسة — Sentinel Errors

أخطاء مُعرّفة كمتغيرات على مستوى الحزمة، تُستخدم للمقارنة:

main.go

package main

import (
    "errors"
    "fmt"
)

// أخطاء حارسة — Sentinel errors
var (
    ErrNotFound     = errors.New("غير موجود")
    ErrUnauthorized = errors.New("غير مصرح")
    ErrForbidden    = errors.New("ممنوع الوصول")
)

// محاكاة طلب — Simulate request
func getResource(id int, role string) (string, error) {
    if role == "" {
        return "", ErrUnauthorized
    }
    if role != "admin" {
        return "", ErrForbidden
    }
    if id > 100 {
        return "", ErrNotFound
    }
    return fmt.Sprintf("مورد #%d", id), nil
}

func main() {
    cases := []struct {
        id   int
        role string
    }{
        {1, "admin"},
        {1, ""},
        {1, "user"},
        {999, "admin"},
    }

    for _, c := range cases {
        result, err := getResource(c.id, c.role)
        switch {
        case err == nil:
            fmt.Printf("✅ النتيجة: %s\n", result)
        case errors.Is(err, ErrUnauthorized):
            fmt.Println("🔐 يجب تسجيل الدخول أولاً")
        case errors.Is(err, ErrForbidden):
            fmt.Println("🚫 ليس لديك صلاحيات كافية")
        case errors.Is(err, ErrNotFound):
            fmt.Println("❓ المورد غير موجود")
        default:
            fmt.Println("❌ خطأ غير متوقع:", err)
        }
    }
}

Output:

أنواع أخطاء مخصصة — Custom Error Types

عندما تحتاج أن يحمل الخطأ بيانات إضافية:

main.go

package main

import (
    "errors"
    "fmt"
)

// خطأ التحقق — Validation error
type ValidationError struct {
    Field   string
    Value   interface{}
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("خطأ في الحقل '%s' (القيمة: %v): %s", e.Field, e.Value, e.Message)
}

// خطأ HTTP — HTTP error
type HTTPError struct {
    StatusCode int
    Status     string
    Body       string
}

func (e *HTTPError) Error() string {
    return fmt.Sprintf("HTTP %d %s: %s", e.StatusCode, e.Status, e.Body)
}

// دالة تتحقق من البريد — Validate email
func validateEmail(email string) error {
    if email == "" {
        return &ValidationError{
            Field:   "email",
            Value:   email,
            Message: "لا يمكن أن يكون فارغاً",
        }
    }
    for _, ch := range email {
        if ch == '@' {
            return nil
        }
    }
    return &ValidationError{
        Field:   "email",
        Value:   email,
        Message: "يجب أن يحتوي على @",
    }
}

func main() {
    emails := []string{"", "invalid", "ahmed@example.com"}

    for _, email := range emails {
        err := validateEmail(email)
        if err != nil {
            fmt.Println("❌", err)

            // استخدام errors.As للوصول لبيانات الخطأ
            // Use errors.As to access error data
            var ve *ValidationError
            if errors.As(err, &ve) {
                fmt.Printf("   الحقل: %s، القيمة: %q\n", ve.Field, ve.Value)
            }
        } else {
            fmt.Printf("✅ %s صالح\n", email)
        }
    }
}

Output:

errors.Is vs errors.As

errors.Is(err, target) — يفحص هل الخطأ (أو أي خطأ مُغلّف داخله) يساوي target errors.As(err, &target) — يبحث عن خطأ من نوع معين ويُحوّله

// errors.Is — مقارنة بقيمة — Compare by value
if errors.Is(err, ErrNotFound) { ... }

// errors.As — مقارنة بنوع — Compare by type
var ve *ValidationError
if errors.As(err, &ve) {
    // ve الآن يحتوي بيانات الخطأ
    fmt.Println(ve.Field)
}

panic و recover

panic يوقف البرنامج فوراً. recover يلتقط panic ويمنع الانهيار. استخدمهما بحذر شديد!

main.go

package main

import "fmt"

// دالة آمنة تلتقط panic — Safe function that catches panic
func safeDiv(a, b int) (result int, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("panic ملتقط: %v", r)
        }
    }()

    // هذا سيسبب panic إذا b == 0
    // This will panic if b == 0
    return a / b, nil
}

// دالة تسبب panic عمداً — Function that intentionally panics
func mustPositive(n int) int {
    if n < 0 {
        panic(fmt.Sprintf("القيمة يجب أن تكون موجبة، استلمت: %d", n))
    }
    return n
}

func main() {
    // التقاط panic من القسمة على صفر — Catch division by zero panic
    result, err := safeDiv(10, 3)
    fmt.Printf("10 / 3 = %d (خطأ: %v)\n", result, err)

    result, err = safeDiv(10, 0)
    fmt.Printf("10 / 0 = %d (خطأ: %v)\n", result, err)

    // استخدام must — Using must pattern
    fmt.Println("القيمة:", mustPositive(42))

    // هذا سيسبب panic — This will panic
    // mustPositive(-1) // لا تفعل هذا بدون recover!
}

Output:

متى تستخدم كل نمط؟

الأداة	متى تُستخدم
`errors.New`	خطأ بسيط بدون بيانات
`fmt.Errorf`	خطأ مع سياق أو تغليف
Custom type	خطأ يحمل بيانات إضافية
Sentinel	خطأ معروف يُقارن مباشرة
`panic`	حالة مستحيلة (bug في البرنامج)
`recover`	خوادم HTTP (لا تريد أن يتوقف الخادم بسبب طلب واحد)

القاعدة الأهم: panic ليس بديلاً لمعالجة الأخطاء! استخدمه فقط للحالات المستحيلة منطقياً (مثل index خارج النطاق في كود يجب أن يكون صحيحاً).

نمط Must

تجد أحياناً دوال بادئة بـ Must — هذه تستدعي panic عند الخطأ:

main.go

package main

import (
    "fmt"
    "regexp"
)

// دالة Must مخصصة — Custom Must function
func MustParseInt(s string) int {
    var n int
    _, err := fmt.Sscanf(s, "%d", &n)
    if err != nil {
        panic(fmt.Sprintf("فشل تحويل %q إلى رقم: %v", s, err))
    }
    return n
}

func main() {
    // regexp.MustCompile — مثال من المكتبة القياسية
    // Standard library example
    re := regexp.MustCompile(`\d+`)
    fmt.Println("الأرقام:", re.FindAllString("عمري 25 سنة ولدي 3 أطفال", -1))

    // Must مخصصة — Custom Must
    age := MustParseInt("25")
    fmt.Println("العمر:", age)
}

Output:

تذكّر: Must تُستخدم فقط عند التهيئة (initialization) — في main أو init أو على مستوى الحزمة — وليس في كود يعمل أثناء تشغيل البرنامج.

تحدي — Challenge

package main

import (
    "errors"
    "fmt"
)

var ErrNotFound = errors.New("غير موجود")

type AuthError struct {
    Reason string
}

func (e *AuthError) Error() string {
    return "خطأ مصادقة: " + e.Reason
}

func process(id int) (int, error) {
    if id == 0 {
        return 0, &AuthError{Reason: "كلمة المرور منتهية"}
    }
    if id > 50 {
        return 0, fmt.Errorf("المورد %d غير موجود: %w", id, ErrNotFound)
    }
    return id, nil
}

func main() {
    for _, id := range []int{42, 0, 99} {
        result, err := process(id)
        if err != nil {
            // استخدم errors.As للتحقق من AuthError و errors.Is للتحقق من ErrNotFound
            // اكتب الكود هنا
            _ = result
        } else {
            fmt.Printf("✅ معالجة ناجحة: %d\n", result)
        }
    }
}