كيف يعمل embedding الهياكل (التكوين)؟

Question

Accepted Answer

Go لا يملك **inheritance** — بدلاً من ذلك يستخدم **composition** عبر struct embedding. من خلال embedding هيكل واحد (أو interface) داخل آخر، يحصل النوع الخارجي على الحقول والدوال الخاصة بالنوع الداخلي مباشرة. هذا هو جواب Go على إعادة استخدام الكود، مفضلاً "has-a" composition على "is-a" inheritance.

## Embedding هيكل

```go
type Animal struct {
    Name string
}
func (a Animal) Eat() string {
    return a.Name + " is eating"
}

type Dog struct {
    Animal    // EMBEDDED — no field name, just the type → composition
    Breed string
}

d := Dog{
    Animal: Animal{Name: "Rex"},
    Breed:  "Lab",
}

// Dog gets Animal's fields and methods PROMOTED — accessed directly
fmt.Println(d.Name)     // "Rex" — promoted from the embedded Animal
fmt.Println(d.Eat())    // "Rex is eating" — Animal's method, called on Dog
```

Embedding (كتابة اسم النوع فقط، بدون اسم حقل) **يرفع** حقول ودوال النوع المدمج إلى الهيكل الخارجي — بحيث `d.Name` و `d.Eat()` تعمل كما لو كانت تابعة ل `Dog`. هذا يبدو كـ inheritance لكنه composition: `Dog` *يملك* `Animal`.

## تجاوز الدوال المرفوعة

```go
func (d Dog) Eat() string {        // Dog defines its OWN Eat()
    return d.Name + " the dog eats noisily"
}
d.Eat()         // calls Dog's Eat (the outer one shadows the embedded one)
d.Animal.Eat()  // explicitly call the embedded Animal's Eat if needed
```

يمكن للنوع الخارجي تعريف دالة بنفس الاسم "تجاوز" (shadow) المرفوعة؛ لا يزال بإمكانك الوصول للإصدار المدمج بشكل صريح.

## Embedding interfaces (شائع جداً)

```go
// embed interfaces to compose larger ones
type Reader interface { Read(p []byte) (int, error) }
type Writer interface { Write(p []byte) (int, error) }

type ReadWriter interface {   // composed from both via embedding
    Reader
    Writer
}
// (this is exactly how io.ReadWriter is defined in the standard library)
```

Interface embedding يكون interfaces صغيرة في interfaces أكبر — يُستخدم في جميع أنحاء المكتبة القياسية.

## Composition على inheritance — فلسفة Go

```text
No class hierarchies, no "extends". Instead:
  ✓ Embed to reuse fields/methods (has-a)
  ✓ Embed interfaces to compose behavior contracts
  ✓ Avoids the fragility, deep hierarchies, and tight coupling of inheritance
```

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

Struct embedding هو آلية Go المميزة **لإعادة استخدام الكود والتكوين**، محل محل inheritance الموجود في معظم لغات OOP.

فهمها ضروري لأنها كيفية تحقيق Go الإعادة (رفع حقول/دوال مدمجة بحيث يرث النوع الخارجي السلوك من خلال composition) مع تجنب قصدي لمشاكل inheritance المعروفة (fragile base classes،계층الهرمية الصارمة العميقة، tight coupling).

هذا يجسد المبدأ الموصى به على نطاق واسع **"composition over inheritance."** يظهر Embedding باستمرار — embedding الهياكل لإعادة الاستخدام، embedding interfaces لبناء عقود أكبر (مثل `io.ReadWriter`)، و embedding للسلوك mixin-style.

التعرف على أن Go لا يملك inheritance وأن embedding هو بديله للتكوين — بالإضافة إلى قواعد method-promotion و shadowing — أمر أساسي لقراءة وتصميم idiomatic Go، وموضوع مشترك في المقابلات بالنظر إلى كيفية اختلافه عن لغات class-based.