أنماط التصميم

أنماط التصميم — Design Patterns

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

نمط الخيارات الوظيفية — Functional Options

هذا النمط يحل مشكلة الدوال التي تقبل إعدادات كثيرة اختيارية:

main.go

package main

import "fmt"

// الخادم — Server
type Server struct {
    Host         string
    Port         int
    MaxConns     int
    ReadTimeout  int // بالثواني
    WriteTimeout int
    TLS          bool
}

// نوع الخيار — Option type
type Option func(*Server)

// خيارات — Options
func WithPort(port int) Option {
    return func(s *Server) { s.Port = port }
}

func WithMaxConns(n int) Option {
    return func(s *Server) { s.MaxConns = n }
}

func WithTLS(enabled bool) Option {
    return func(s *Server) { s.TLS = enabled }
}

func WithTimeouts(read, write int) Option {
    return func(s *Server) {
        s.ReadTimeout = read
        s.WriteTimeout = write
    }
}

// المُنشئ — Constructor
func NewServer(host string, opts ...Option) *Server {
    // القيم الافتراضية — Defaults
    s := &Server{
        Host:         host,
        Port:         8080,
        MaxConns:     100,
        ReadTimeout:  30,
        WriteTimeout: 30,
        TLS:          false,
    }

    // تطبيق الخيارات — Apply options
    for _, opt := range opts {
        opt(s)
    }

    return s
}

func main() {
    // خادم بالإعدادات الافتراضية — Server with defaults
    s1 := NewServer("localhost")
    fmt.Printf("افتراضي: %s:%d (TLS: %v, MaxConns: %d)\n",
        s1.Host, s1.Port, s1.TLS, s1.MaxConns)

    // خادم مخصص — Custom server
    s2 := NewServer("api.example.com",
        WithPort(443),
        WithTLS(true),
        WithMaxConns(1000),
        WithTimeouts(60, 60),
    )
    fmt.Printf("مخصص: %s:%d (TLS: %v, MaxConns: %d)\n",
        s2.Host, s2.Port, s2.TLS, s2.MaxConns)
}

Output:

لماذا هذا النمط مميز:

API نظيف وقابل للتوسع
القيم الافتراضية واضحة
إضافة خيارات جديدة لا تكسر الكود القائم
وثائقي بذاته — WithTLS(true) واضح

نمط Builder

main.go

package main

import (
    "fmt"
    "strings"
)

// بنّاء الاستعلام — Query builder
type QueryBuilder struct {
    table      string
    conditions []string
    orderBy    string
    limit      int
    columns    []string
}

func NewQuery(table string) *QueryBuilder {
    return &QueryBuilder{
        table:   table,
        columns: []string{"*"},
    }
}

func (q *QueryBuilder) Select(cols ...string) *QueryBuilder {
    q.columns = cols
    return q // إرجاع self للسلسلة — Return self for chaining
}

func (q *QueryBuilder) Where(condition string) *QueryBuilder {
    q.conditions = append(q.conditions, condition)
    return q
}

func (q *QueryBuilder) OrderBy(col string) *QueryBuilder {
    q.orderBy = col
    return q
}

func (q *QueryBuilder) Limit(n int) *QueryBuilder {
    q.limit = n
    return q
}

func (q *QueryBuilder) Build() string {
    query := fmt.Sprintf("SELECT %s FROM %s",
        strings.Join(q.columns, ", "), q.table)

    if len(q.conditions) > 0 {
        query += " WHERE " + strings.Join(q.conditions, " AND ")
    }
    if q.orderBy != "" {
        query += " ORDER BY " + q.orderBy
    }
    if q.limit > 0 {
        query += fmt.Sprintf(" LIMIT %d", q.limit)
    }
    return query
}

func main() {
    // سلسلة استدعاءات — Method chaining
    query := NewQuery("users").
        Select("id", "name", "email").
        Where("age > 18").
        Where("active = true").
        OrderBy("name ASC").
        Limit(10).
        Build()

    fmt.Println(query)

    // استعلام بسيط — Simple query
    simple := NewQuery("products").
        Where("price < 100").
        Build()

    fmt.Println(simple)
}

Output:

حقن الاعتماديات — Dependency Injection

في Go، حقن الاعتماديات يتم ببساطة عبر الواجهات والمُنشئات:

main.go

package main

import "fmt"

// واجهات — Interfaces
type Logger interface {
    Log(msg string)
}

type Database interface {
    Save(key, value string) error
    Get(key string) (string, error)
}

// تنفيذ Logger — Logger implementation
type ConsoleLogger struct{}

func (l *ConsoleLogger) Log(msg string) {
    fmt.Println("[LOG]", msg)
}

// تنفيذ Database — Database implementation
type MemoryDB struct {
    data map[string]string
}

func (db *MemoryDB) Save(key, value string) error {
    db.data[key] = value
    return nil
}

func (db *MemoryDB) Get(key string) (string, error) {
    v, ok := db.data[key]
    if !ok {
        return "", fmt.Errorf("المفتاح '%s' غير موجود", key)
    }
    return v, nil
}

// الخدمة — تعتمد على واجهات وليس أنواع محددة!
// Service — depends on interfaces, not concrete types!
type UserService struct {
    logger Logger
    db     Database
}

func NewUserService(logger Logger, db Database) *UserService {
    return &UserService{logger: logger, db: db}
}

func (s *UserService) CreateUser(name string) {
    s.logger.Log(fmt.Sprintf("إنشاء مستخدم: %s", name))
    s.db.Save("user:"+name, name)
    s.logger.Log("تم الحفظ ✅")
}

func main() {
    // تجميع الاعتماديات — Wire dependencies
    logger := &ConsoleLogger{}
    db := &MemoryDB{data: make(map[string]string)}
    service := NewUserService(logger, db)

    service.CreateUser("أحمد")
    service.CreateUser("فاطمة")

    // يمكن استبدال أي اعتمادية بسهولة — Easy to swap
    fmt.Println("\n💡 في الاختبار: MockLogger + MockDB")
    fmt.Println("💡 في الإنتاج: FileLogger + PostgresDB")
}

Output:

نمط تجمّع العمال — Worker Pool

main.go

package main

import (
    "fmt"
    "sync"
    "time"
)

// تجمّع عمال معمم — Generic worker pool
func WorkerPool[T any, R any](
    workers int,
    jobs []T,
    process func(T) R,
) []R {
    jobCh := make(chan T, len(jobs))
    resultCh := make(chan R, len(jobs))

    // بدء العمال — Start workers
    var wg sync.WaitGroup
    for w := 0; w < workers; w++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for job := range jobCh {
                result := process(job)
                resultCh <- result
            }
        }(w)
    }

    // إرسال المهام — Send jobs
    for _, job := range jobs {
        jobCh <- job
    }
    close(jobCh)

    // انتظار وإغلاق — Wait and close
    go func() {
        wg.Wait()
        close(resultCh)
    }()

    // جمع النتائج — Collect results
    var results []R
    for r := range resultCh {
        results = append(results, r)
    }
    return results
}

func main() {
    start := time.Now()

    // معالجة 10 مهام بـ 3 عمال — Process 10 jobs with 3 workers
    jobs := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

    results := WorkerPool(3, jobs, func(n int) string {
        time.Sleep(50 * time.Millisecond) // محاكاة عمل
        return fmt.Sprintf("%d → %d", n, n*n)
    })

    for _, r := range results {
        fmt.Println(r)
    }
    fmt.Printf("\nالوقت: %v (بدلاً من ~500ms تسلسلياً)\n",
        time.Since(start).Round(time.Millisecond))
}

Output:

نمط الأنابيب — Pipeline Pattern

main.go

package main

import "fmt"

// كل مرحلة تأخذ قناة وتُرجع قناة — Each stage takes and returns a channel
func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func double(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * 2
        }
        close(out)
    }()
    return out
}

func addTen(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n + 10
        }
        close(out)
    }()
    return out
}

func toString(in <-chan int) <-chan string {
    out := make(chan string)
    go func() {
        for n := range in {
            out <- fmt.Sprintf("النتيجة: %d", n)
        }
        close(out)
    }()
    return out
}

func main() {
    // ربط المراحل: توليد → ضعف → +10 → نص
    // Chain: generate → double → addTen → toString
    pipeline := toString(addTen(double(generate(1, 2, 3, 4, 5))))

    for s := range pipeline {
        fmt.Println(s)
    }
    // 1→2→12, 2→4→14, 3→6→16, 4→8→18, 5→10→20
}

Output:

تحدي — Challenge

package main

import "fmt"

type Server struct {
    Host    string
    Port    int
    TLS     bool
    Timeout int
}

type Option func(*Server)

// أكمل دوال الخيارات — اكتب الكود هنا
func WithPort(p int) Option     { return func(s *Server) {} }
func WithTLS(t bool) Option     { return func(s *Server) {} }
func WithTimeout(t int) Option  { return func(s *Server) {} }

// أكمل NewServer مع قيم افتراضية وتطبيق الخيارات
func NewServer(host string, opts ...Option) *Server {
    // اكتب الكود هنا
    return &Server{Host: host}
}

func main() {
    s := NewServer("api.local", WithPort(9090), WithTLS(true), WithTimeout(60))
    fmt.Printf("خادم: %s:%d (TLS: %v, Timeout: %ds)\n", s.Host, s.Port, s.TLS, s.Timeout)
}