كيف تعمل الواجهات (Interfaces) في Go؟

Question

Accepted Answer

**الواجهة** (interface) في Go تحدد مجموعة من توقيعات الدوال — عقد يمثل سلوك معين. والجزء الحاسم هو أن الواجهات يتم تلبيتها **بشكل ضمني**: أي نوع (type) يحتوي على تلك الدوال يلبي الواجهة تلقائياً، **بدون الحاجة لتصريح صريح "implements"**. هذا النهج الهيكلي (structural) والمبني على duck-typing فريد وقوي جداً.

## تعريف الواجهات والتنفيذ الضمني

```go
// define an interface — a set of method signatures
type Speaker interface {
    Speak() string
}

type Dog struct{}
func (d Dog) Speak() string { return "Woof" }   // Dog has Speak() → it IS a Speaker

type Cat struct{}
func (c Cat) Speak() string { return "Meow" }   // Cat too — implicitly

// NO "implements Speaker" anywhere — satisfaction is automatic
var s Speaker = Dog{}    // works because Dog has the Speak() method
s.Speak()                // "Woof"
```

لا توجد كلمة مفتاحية `implements` — إذا كان لدى النوع جميع دوال الواجهة، فهو يلبي الواجهة تلقائياً. هذا يفصل الواجهة عن تنفيذاتها (المنفذ لا يحتاج حتى أن يعرف أن الواجهة موجودة).

## تعدد الأشكال (Polymorphism) عبر الواجهات

```go
func announce(s Speaker) {        // accepts ANY type that has Speak()
    fmt.Println(s.Speak())
}
announce(Dog{})    // "Woof"
announce(Cat{})    // "Meow"

speakers := []Speaker{Dog{}, Cat{}}   // a slice of different types via the interface
for _, sp := range speakers { sp.Speak() }
```

الواجهات تفعّل تعدد الأشكال — اكتب الكود بناءً على السلوك المطلوب، وأي نوع متوافق سيعمل.

## الواجهة الفارغة و `any`

```go
var x interface{}     // the empty interface — satisfied by EVERY type (no methods required)
x = 42
x = "hello"
// Go 1.18+: `any` is an alias for interface{}
func print(v any) { fmt.Println(v) }   // accepts anything
```

الواجهة الفارغة (`interface{}` / `any`) تحتفظ بأي قيمة — تُستخدم عندما لا نعرف النوع مسبقاً (رغم أن الـ generics الآن غالباً ما تحل محلها).

## واجهات مكتبة المعايير التي ستستخدمها باستمرار

```go
type Stringer interface { String() string }   // controls fmt printing
type error interface { Error() string }        // the error type itself!
type io.Reader interface { Read(p []byte) (n int, err error) }
type io.Writer interface { Write(p []byte) (n int, err error) }
```

معظم مكتبة المعايير مبنية على واجهات صغيرة (`io.Reader`/`io.Writer`, `error`, `Stringer`) — تنفيذها يجعل أنواعك تعمل مع النظام البيئي بأكمله.

## الأسلوب: قبول الواجهات، إرجاع الـ structs

```text
Go favors SMALL interfaces (often one method) defined where they're USED (the consumer),
not where types are defined. "The bigger the interface, the weaker the abstraction."
```

## لماذا هذا مهم

الواجهات مركزية في تصميم Go ونهجها للتجريد والـ polymorphism — و**التلبية الضمنية** (بدون كلمة `implements`؛ الكتابة الهيكلية) هي أحدى أكثر الميزات تمييزاً وقوة في اللغة.

هذا الفصل يعني أن الأنواع والواجهات تتطور بشكل مستقل، يمكنك تعريف الواجهات *بعد* الأنواع التي تلبيها، وأي نوع متوافق يندمج مع الكود القائم على الواجهات تلقائياً — مما يمكّن تصاميم مرنة وضعيفة الاقتران وسهلة الاختبار (استبدل التنفيذات الوهمية بسهولة).

فهم التنفيذ الضمني، و polymorphism عبر الواجهات، والواجهة الفارغة/`any`، ونمط الواجهات الصغيرة ("قبول الواجهات، إرجاع structs")، والواجهات الموجودة في مكتبة المعايير (`error`, `io.Reader`/`Writer`, `Stringer`) ضروري لكود Go احترافي.

إنها موضوع متكرر في المقابلات تماماً لأن النموذج الضمني والهيكلي يختلف بشكل جذري عن الواجهات الصريحة في Java و C#.

تعريف الواجهات والتنفيذ الضمني

تعدد الأشكال (Polymorphism) عبر الواجهات

الواجهة الفارغة و any

واجهات مكتبة المعايير التي ستستخدمها باستمرار

الأسلوب: قبول الواجهات، إرجاع الـ structs

لماذا هذا مهم

الواجهة الفارغة و `any`