struct embedding (composition) कसरी काम गर्छ?

Question

Accepted Answer

Go मा **कोई inheritance छैन** — यसको सट्टा यो **composition** को प्रयोग गर्छ struct embedding को माध्यमबाट। एक struct (वा interface) लाई अर्कोको भित्र embed गरेर, बाहिरी प्रकार भित्री प्रकारका fields र methods सीधै पाउँछ। यो कोड पुन: प्रयोगको लागि Go को जवाफ हो, "is-a" inheritance भन्दा "has-a" composition लाई प्राथमिकता दिन्छ।

## Struct 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 (केवल प्रकार नाम लेखिएको, कोई field नाम छैन) embedded प्रकारका fields र methods लाई बाहिरी struct मा **promote** गर्छ — त्यसैले `d.Name` र `d.Eat()` काम गर्छ जस्तै तिनीहरु `Dog` मा थिए। यो inheritance जस्तो देखिन्छ तर composition हो: `Dog` *को* `Animal` छ।

## Promoted methods को override गर्नु

```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
```

बाहिरी प्रकार promoted एक जस्तै नाम सहित method परिभाषित गर्न सक्छ "override" (shadow) गर्न; तपाईंले अभी पनि embedded संस्करण स्पष्ट रुपमा पहुँच गर्न सक्नुहुन्छ।

## Interfaces Embedding (धेरै सामान्य)

```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 लाई ठूलो ones मा compose गर्छ — standard library मा सर्वत्र प्रयोग गरिन्छ।

## Composition over 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 **कोड पुन: प्रयोग र composition** को लागि Go को विशिष्ट प्रक्रिया हो, जो अधिकांश OOP भाषाहरुमा पाइने inheritance लाई प्रतिस्थापन गर्छ।

í बुझ्नु आवश्यक छ किनकि यो कसरी Go reuse गर्छ (embedded fields/methods promote गरेर त्यसैले बाहिरी प्रकार composition को माध्यमबाट व्यवहार "inherit" गर्छ) जबकि जानबूझेर inheritance का सुप्रसिद्ध समस्याहरु (fragile base classes, गहिरो कठोर hierarchies, कसिएको coupling) लाई बेवास्ता गर्छ।

यो व्यापकरुपमा अनुमोदित सिद्धान्त **"composition over inheritance"** लाई मूर्त रुप दिन्छ। Embedding सर्वत्र दिखिन्छ — reuse को लागि structs embed गर्नु, ठूलो contracts build गर्न interfaces embed गर्नु (जस्तै `io.ReadWriter`), र mixin-style व्यवहारको लागि embedding।

यो मान्यता कि Go मा कोई inheritance छैन र embedding यसको compositional विकल्प हो — साथै method-promotion र shadowing नियमहरु — idiomatic Go पढ्न र डिजाइन गर्न आवश्यक छ, र एक सामान्य साक्षात्कार विषय हो किनकि यो class-based भाषाहरु भन्दा कसरी फरक छ।