السياق

السياق — Context

context.Context هي واحدة من أهم واجهات Go — تُستخدم لإلغاء العمليات، تحديد المهل الزمنية، وتمرير بيانات عبر طبقات البرنامج. كل طلب HTTP، كل استعلام قاعدة بيانات، كل عملية طويلة — يجب أن تأخذ context.

لماذا Context؟

تخيّل مستخدم فتح صفحة ثم أغلق المتصفح. بدون context، الخادم يستمر في المعالجة بلا فائدة! مع context، الخادم يعرف أن العميل رحل ويتوقف فوراً.

أنواع Context

main.go

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // 1. context.Background — الجذر — Root context
    ctx := context.Background()
    fmt.Printf("Background: %v\n", ctx)

    // 2. context.TODO — مؤقت حتى تقرر ماذا تستخدم
    todoCtx := context.TODO()
    fmt.Printf("TODO: %v\n", todoCtx)

    // 3. WithCancel — إلغاء يدوي — Manual cancellation
    cancelCtx, cancel := context.WithCancel(ctx)
    fmt.Printf("WithCancel: %v (Err: %v)\n", cancelCtx, cancelCtx.Err())
    cancel() // إلغاء!
    fmt.Printf("بعد الإلغاء: Err = %v\n", cancelCtx.Err())

    // 4. WithTimeout — إلغاء بعد مدة — Auto-cancel after duration
    timeoutCtx, timeoutCancel := context.WithTimeout(ctx, 100*time.Millisecond)
    defer timeoutCancel()
    fmt.Printf("WithTimeout: deadline in 100ms\n")

    // 5. WithDeadline — إلغاء في وقت محدد
    deadline := time.Now().Add(5 * time.Second)
    deadlineCtx, deadlineCancel := context.WithDeadline(ctx, deadline)
    defer deadlineCancel()
    d, _ := deadlineCtx.Deadline()
    fmt.Printf("WithDeadline: %v\n", d.Format("15:04:05"))

    _ = timeoutCtx
}

Output:

الإلغاء — Cancellation

main.go

package main

import (
    "context"
    "fmt"
    "time"
)

// عملية طويلة قابلة للإلغاء — Long operation with cancellation
func longOperation(ctx context.Context, name string) {
    for i := 1; i <= 10; i++ {
        select {
        case <-ctx.Done():
            fmt.Printf("[%s] ⛔ تم الإلغاء عند الخطوة %d: %v\n", name, i, ctx.Err())
            return
        default:
            fmt.Printf("[%s] الخطوة %d\n", name, i)
            time.Sleep(50 * time.Millisecond)
        }
    }
    fmt.Printf("[%s] ✅ اكتمل!\n", name)
}

func main() {
    // إلغاء يدوي بعد 150ms — Cancel manually after 150ms
    ctx, cancel := context.WithCancel(context.Background())

    go longOperation(ctx, "عملية-1")

    time.Sleep(150 * time.Millisecond)
    cancel() // إلغاء!
    time.Sleep(50 * time.Millisecond)

    fmt.Println("\n--- المهلة الزمنية ---")

    // مهلة 120ms — Timeout after 120ms
    timeoutCtx, timeoutCancel := context.WithTimeout(context.Background(), 120*time.Millisecond)
    defer timeoutCancel()

    longOperation(timeoutCtx, "عملية-2")
}

Output:

WithValue — تمرير بيانات

main.go

package main

import (
    "context"
    "fmt"
)

// مفاتيح مخصصة — Custom keys (تجنّب string!)
type contextKey string

const (
    userIDKey    contextKey = "userID"
    requestIDKey contextKey = "requestID"
)

// دالة تقرأ من Context — Read from context
func processRequest(ctx context.Context) {
    userID, ok := ctx.Value(userIDKey).(int)
    if !ok {
        fmt.Println("❌ لا يوجد userID في السياق")
        return
    }

    requestID, _ := ctx.Value(requestIDKey).(string)
    fmt.Printf("معالجة الطلب %s للمستخدم %d\n", requestID, userID)
}

func main() {
    ctx := context.Background()

    // إضافة قيم — Add values
    ctx = context.WithValue(ctx, userIDKey, 42)
    ctx = context.WithValue(ctx, requestIDKey, "req-abc-123")

    processRequest(ctx)

    // سياق بدون userID — Context without userID
    emptyCtx := context.Background()
    processRequest(emptyCtx)
}

Output:

تحذير: لا تستخدم WithValue لتمرير معاملات الدوال! استخدمها فقط للبيانات العابرة (request ID, auth token, trace ID).

Context في الواقع — Real-World Patterns

main.go

package main

import (
    "context"
    "fmt"
    "time"
)

// محاكاة استعلام قاعدة بيانات — Simulated DB query
func queryDB(ctx context.Context, query string) (string, error) {
    // محاكاة استعلام بطيء — Simulate slow query
    select {
    case <-time.After(200 * time.Millisecond):
        return fmt.Sprintf("نتائج: %s", query), nil
    case <-ctx.Done():
        return "", fmt.Errorf("الاستعلام أُلغي: %w", ctx.Err())
    }
}

// محاكاة استدعاء API — Simulated API call
func callAPI(ctx context.Context, url string) (string, error) {
    select {
    case <-time.After(100 * time.Millisecond):
        return fmt.Sprintf("بيانات من %s", url), nil
    case <-ctx.Done():
        return "", fmt.Errorf("الطلب أُلغي: %w", ctx.Err())
    }
}

func handleRequest(ctx context.Context) {
    // كلا العمليتين تحترمان نفس السياق — Both respect same context
    apiData, err := callAPI(ctx, "/api/users")
    if err != nil {
        fmt.Println("API:", err)
        return
    }
    fmt.Println("API:", apiData)

    dbData, err := queryDB(ctx, "SELECT * FROM users")
    if err != nil {
        fmt.Println("DB:", err)
        return
    }
    fmt.Println("DB:", dbData)
}

func main() {
    // مهلة كافية — Enough timeout
    fmt.Println("=== مهلة كافية (500ms) ===")
    ctx1, cancel1 := context.WithTimeout(context.Background(), 500*time.Millisecond)
    defer cancel1()
    handleRequest(ctx1)

    // مهلة قصيرة — Short timeout
    fmt.Println("\n=== مهلة قصيرة (150ms) ===")
    ctx2, cancel2 := context.WithTimeout(context.Background(), 150*time.Millisecond)
    defer cancel2()
    handleRequest(ctx2)
}

Output:

قواعد Context الذهبية

Context هو المعامل الأول دائماً: func DoSomething(ctx context.Context, ...)
لا تخزّنه في struct — مرّره كمعامل
استخدم context.Background() في main و context.TODO() مؤقتاً
دائماً استدعِ cancel: defer cancel()
WithValue للبيانات العابرة فقط — ليس لمعاملات الدوال

تحدي — Challenge

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // أنشئ context بمهلة 150ms
    // اكتب الكود هنا
    ctx, cancel := context.WithTimeout(context.Background(), 150*time.Millisecond)
    defer cancel()

    // عملية سريعة (100ms) — استخدم select مع time.After و ctx.Done
    // اكتب الكود هنا

    // عملية بطيئة (200ms) — استخدم select مع time.After و ctx.Done
    // اكتب الكود هنا
    _ = ctx
}