الواجهات

الواجهات — Interfaces

الواجهات هي من أجمل مفاهيم Go وأكثرها أناقة. الفكرة بسيطة لكنها عميقة: الواجهة تُعرّف سلوكاً، لا بنية. أي نوع يُنفّذ أساليب الواجهة يُحقق تلك الواجهة تلقائياً — بدون كلمة implements ولا تسجيل صريح.

هذا المبدأ يُعرف بـ التنفيذ الضمني (Implicit Implementation)، وهو ما يجعل Go مختلفة عن أغلب اللغات.

تعريف واجهة

الواجهة هي مجموعة من توقيعات الأساليب (method signatures):

// واجهة الشكل — Shape interface
type Shape interface {
    Area() float64
    Perimeter() float64
}

أي نوع يملك أسلوبي Area() و Perimeter() بنفس التوقيعات يُحقق واجهة Shape — تلقائياً!

مثال عملي كامل

main.go

package main

import (
    "fmt"
    "math"
)

// تعريف الواجهة — Define interface
type Shape interface {
    Area() float64
    Perimeter() float64
}

// المستطيل — Rectangle
type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64      { return r.Width * r.Height }
func (r Rectangle) Perimeter() float64 { return 2 * (r.Width + r.Height) }

// الدائرة — Circle
type Circle struct {
    Radius float64
}

func (c Circle) Area() float64      { return math.Pi * c.Radius * c.Radius }
func (c Circle) Perimeter() float64 { return 2 * math.Pi * c.Radius }

// دالة تعمل مع أي شكل — Works with any Shape
func printShapeInfo(s Shape) {
    fmt.Printf("المساحة: %.2f، المحيط: %.2f\n", s.Area(), s.Perimeter())
}

func main() {
    shapes := []Shape{
        Rectangle{Width: 5, Height: 3},
        Circle{Radius: 4},
        Rectangle{Width: 10, Height: 2},
    }

    for _, s := range shapes {
        printShapeInfo(s)
    }
}

Output:

لاحظ: لم نكتب Rectangle implements Shape في أي مكان! Go اكتشف ذلك تلقائياً لأن Rectangle يملك كل الأساليب المطلوبة.

لماذا التنفيذ الضمني مهم؟

فصل الاعتماديات — يمكنك تعريف واجهة في حزمة وتنفيذها في حزمة أخرى بدون أي استيراد
اختبار أسهل — أنشئ أنواع وهمية (mocks) بسهولة
مرونة — أضف واجهات لاحقاً بدون تعديل الكود الموجود

الواجهة الفارغة — Empty Interface

interface{} (أو any منذ Go 1.18) هي واجهة بدون أي أساليب. لأن كل نوع يُحقق صفر أساليب، كل نوع يُحقق الواجهة الفارغة:

main.go

package main

import "fmt"

// دالة تقبل أي شيء — Function that accepts anything
func describe(i interface{}) {
    fmt.Printf("القيمة: %v، النوع: %T\n", i, i)
}

func main() {
    describe(42)
    describe("مرحبا")
    describe(true)
    describe(3.14)
    describe([]int{1, 2, 3})

    // أيضاً يمكن استخدام any (اختصار لـ interface{})
    var x any = "أي شيء"
    fmt.Println(x)
}

Output:

تحذير: استخدام interface{} أو any يُفقدك أمان الأنواع. استخدمها فقط عند الضرورة (مثل fmt.Println التي تقبل أي شيء).

تأكيد الأنواع — Type Assertions

عندما لديك قيمة من نوع واجهة وتريد الوصول للنوع الحقيقي:

main.go

package main

import "fmt"

func main() {
    var i interface{} = "مرحبا بالعالم"

    // تأكيد النوع — Type assertion
    s := i.(string)
    fmt.Println("النص:", s)
    fmt.Println("الطول:", len(s))

    // تأكيد آمن مع ok — Safe assertion with ok
    n, ok := i.(int)
    if ok {
        fmt.Println("الرقم:", n)
    } else {
        fmt.Println("ليس رقماً!")
    }

    // بدون ok — سيسبب panic إذا فشل
    // n2 := i.(int) // panic: interface conversion!
}

Output:

القاعدة: دائماً استخدم الصيغة value, ok := i.(Type) لتجنب panic.

مفتاح الأنواع — Type Switch

بديل أنيق لسلسلة من تأكيدات الأنواع:

main.go

package main

import "fmt"

// وصف القيمة حسب نوعها — Describe value by type
func classify(i interface{}) string {
    switch v := i.(type) {
    case int:
        return fmt.Sprintf("عدد صحيح: %d", v)
    case float64:
        return fmt.Sprintf("عدد عشري: %.2f", v)
    case string:
        return fmt.Sprintf("نص بطول %d: %q", len(v), v)
    case bool:
        if v {
            return "قيمة منطقية: صحيح"
        }
        return "قيمة منطقية: خطأ"
    case []int:
        return fmt.Sprintf("شريحة أعداد بطول %d", len(v))
    default:
        return fmt.Sprintf("نوع غير معروف: %T", v)
    }
}

func main() {
    values := []interface{}{42, 3.14, "Go", true, []int{1, 2, 3}}
    for _, v := range values {
        fmt.Println(classify(v))
    }
}

Output:

واجهات متعددة — Multiple Interfaces

نوع واحد يمكنه تحقيق عدة واجهات:

main.go

package main

import "fmt"

// واجهة القراءة — Reader interface
type Reader interface {
    Read() string
}

// واجهة الكتابة — Writer interface
type Writer interface {
    Write(data string)
}

// واجهة مركبة — Composed interface
type ReadWriter interface {
    Reader
    Writer
}

// نوع يُحقق كلا الواجهتين — Type implementing both
type Document struct {
    Content string
}

func (d *Document) Read() string {
    return d.Content
}

func (d *Document) Write(data string) {
    d.Content = data
    fmt.Println("تم الكتابة:", data)
}

func main() {
    doc := &Document{}

    // يمكن استخدامه كـ ReadWriter
    var rw ReadWriter = doc
    rw.Write("السلام عليكم")
    fmt.Println("القراءة:", rw.Read())

    // أو كـ Reader فقط
    var r Reader = doc
    fmt.Println("قراءة فقط:", r.Read())
}

Output:

تركيب الواجهات — Interface Embedding

يمكنك بناء واجهات من واجهات أخرى (كما رأينا في ReadWriter أعلاه). هذا يُشجع على تعريف واجهات صغيرة ومركزة:

type Reader interface { Read() string }
type Writer interface { Write(string) }
type Closer interface { Close() error }

// واجهة مركبة من ثلاث واجهات — Composed from three interfaces
type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

نصيحة Go: “كلما كانت الواجهة أصغر، كلما كانت أقوى.” واجهة بأسلوب واحد مثل io.Reader أقوى من واجهة بعشرة أساليب.

أخطاء شائعة

خطأ 1: استخدام الواجهة الفارغة في كل مكان

// ❌ تفقد أمان الأنواع
func Process(data interface{}) { ... }

// ✅ عرّف واجهة محددة
type Processor interface {
    Process() Result
}

خطأ 2: نسيان أن مستقبل المؤشر لا يُحقق الواجهة للقيمة

type Saver interface { Save() }
type Doc struct{}
func (d *Doc) Save() {} // مستقبل مؤشر

var s Saver = Doc{}   // ❌ خطأ تجميع! Doc لا يُحقق Saver
var s Saver = &Doc{}  // ✅ *Doc يُحقق Saver

تحدي — Challenge

package main

import "fmt"

// عرّف واجهة الحيوان — Define Animal interface
type Animal interface {
    Name() string
    Speak() string
}

// قطة — Cat
type Cat struct{}

// نفّذ أسلوبي Name و Speak لـ Cat — اكتب الكود هنا
func (c Cat) Name() string  { return "" }
func (c Cat) Speak() string { return "" }

// كلب — Dog
type Dog struct{}

// نفّذ أسلوبي Name و Speak لـ Dog — اكتب الكود هنا
func (d Dog) Name() string  { return "" }
func (d Dog) Speak() string { return "" }

func main() {
    animals := []Animal{Cat{}, Dog{}}
    for _, a := range animals {
        fmt.Printf("حيوان: %s تقول %s\n", a.Name(), a.Speak())
    }
}