عبارة Select

عبارة Select — Select Statement

select هي مثل switch لكن للقنوات. تنتظر عدة عمليات قنوات وتُنفّذ أول واحدة تكون جاهزة. هذا يجعلك تتعامل مع عدة مصادر بيانات متزامنة بأناقة.

select الأساسية

main.go

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    // goroutine بطيء — Slow goroutine
    go func() {
        time.Sleep(200 * time.Millisecond)
        ch1 <- "من القناة الأولى"
    }()

    // goroutine سريع — Fast goroutine
    go func() {
        time.Sleep(100 * time.Millisecond)
        ch2 <- "من القناة الثانية"
    }()

    // select تختار أول قناة جاهزة
    // select picks the first ready channel
    for i := 0; i < 2; i++ {
        select {
        case msg := <-ch1:
            fmt.Println("ch1:", msg)
        case msg := <-ch2:
            fmt.Println("ch2:", msg)
        }
    }
}

Output:

المهل الزمنية — Timeouts

من أهم استخدامات select — تحديد وقت أقصى للانتظار:

main.go

package main

import (
    "fmt"
    "time"
)

// محاكاة طلب بطيء — Simulate slow request
func slowAPI() chan string {
    ch := make(chan string)
    go func() {
        time.Sleep(300 * time.Millisecond) // بطيء!
        ch <- "بيانات من الخادم"
    }()
    return ch
}

func main() {
    // مهلة 200ms — 200ms timeout
    fmt.Println("=== مهلة قصيرة ===")
    select {
    case data := <-slowAPI():
        fmt.Println("النتيجة:", data)
    case <-time.After(200 * time.Millisecond):
        fmt.Println("⏰ انتهت المهلة!")
    }

    // مهلة 500ms — 500ms timeout (enough time)
    fmt.Println("\n=== مهلة كافية ===")
    select {
    case data := <-slowAPI():
        fmt.Println("النتيجة:", data)
    case <-time.After(500 * time.Millisecond):
        fmt.Println("⏰ انتهت المهلة!")
    }
}

Output:

عمليات غير مُعيقة — Non-blocking Operations

أضف default لجعل select لا تنتظر أبداً:

main.go

package main

import "fmt"

func main() {
    ch := make(chan string, 1)

    // محاولة استقبال غير مُعيقة — Non-blocking receive
    select {
    case msg := <-ch:
        fmt.Println("استقبلت:", msg)
    default:
        fmt.Println("لا توجد رسائل متاحة")
    }

    // محاولة إرسال غير مُعيقة — Non-blocking send
    ch <- "مرحبا"
    select {
    case ch <- "رسالة أخرى":
        fmt.Println("تم الإرسال")
    default:
        fmt.Println("القناة ممتلئة، تخطينا الإرسال")
    }

    // الآن نستقبل الرسالة الأولى — Receive the first message
    fmt.Println("الرسالة:", <-ch)
}

Output:

نمط Fan-In — دمج قنوات متعددة

Fan-in يجمع بيانات من عدة مصادر في قناة واحدة:

main.go

package main

import (
    "fmt"
    "time"
)

// مصدر بيانات — Data source
func source(name string, interval time.Duration, count int) <-chan string {
    ch := make(chan string)
    go func() {
        for i := 1; i <= count; i++ {
            time.Sleep(interval)
            ch <- fmt.Sprintf("[%s] رسالة %d", name, i)
        }
        close(ch)
    }()
    return ch
}

// دمج قناتين — Merge two channels (fan-in)
func fanIn(ch1, ch2 <-chan string) <-chan string {
    merged := make(chan string)
    go func() {
        // نتابع حتى تُغلق القناتان — Continue until both close
        for ch1 != nil || ch2 != nil {
            select {
            case msg, ok := <-ch1:
                if !ok {
                    ch1 = nil
                    continue
                }
                merged <- msg
            case msg, ok := <-ch2:
                if !ok {
                    ch2 = nil
                    continue
                }
                merged <- msg
            }
        }
        close(merged)
    }()
    return merged
}

func main() {
    // مصدران بسرعات مختلفة — Two sources at different speeds
    api := source("API", 80*time.Millisecond, 3)
    db := source("قاعدة البيانات", 120*time.Millisecond, 3)

    // دمجهم — Merge them
    all := fanIn(api, db)

    for msg := range all {
        fmt.Println(msg)
    }
    fmt.Println("— انتهى —")
}

Output:

نمط المؤقت الدوري — Ticker Pattern

main.go

package main

import (
    "fmt"
    "time"
)

func main() {
    // مؤقت كل 100ms — Tick every 100ms
    ticker := time.NewTicker(100 * time.Millisecond)
    defer ticker.Stop()

    // مهلة كلية — Overall timeout
    timeout := time.After(350 * time.Millisecond)

    count := 0
    for {
        select {
        case t := <-ticker.C:
            count++
            fmt.Printf("نبضة %d عند %v\n", count, t.Format("15:04:05.000"))
        case <-timeout:
            fmt.Printf("انتهت المهلة بعد %d نبضات\n", count)
            return
        }
    }
}

Output:

نمط done channel — الإلغاء

main.go

package main

import (
    "fmt"
    "time"
)

// عامل قابل للإلغاء — Cancellable worker
func worker(id int, done <-chan struct{}) {
    for {
        select {
        case <-done:
            fmt.Printf("عامل %d: تم إلغائي\n", id)
            return
        default:
            fmt.Printf("عامل %d: أعمل...\n", id)
            time.Sleep(80 * time.Millisecond)
        }
    }
}

func main() {
    done := make(chan struct{})

    go worker(1, done)
    go worker(2, done)

    // دع العمال يعملون قليلاً — Let workers run a bit
    time.Sleep(250 * time.Millisecond)

    // إلغاء الكل — Cancel all
    close(done) // إغلاق القناة يُنبّه كل المستمعين — Closing notifies all listeners
    time.Sleep(50 * time.Millisecond)
    fmt.Println("تم إيقاف كل العمال")
}

Output:

نصيحة: close(done) أفضل من إرسال قيم متعددة لأنه يُنبّه كل المستمعين دفعة واحدة.

تحدي — Challenge

package main

import (
    "fmt"
    "time"
)

func main() {
    fast := make(chan string)
    slow := make(chan string)

    go func() {
        time.Sleep(50 * time.Millisecond)
        fast <- "سريع"
    }()

    go func() {
        time.Sleep(200 * time.Millisecond)
        slow <- "بطيء"
    }()

    // استخدم select لاختيار أول قناة جاهزة — اكتب الكود هنا
}