struct embedding (composition) કેવી રીતે કાર્ય કરે છે?

Question

Accepted Answer

Go માં **વારસાગિરી નથી** — તેના બદલે તે struct embedding દ્વારા **composition** નો ઉપયોગ કરે છે. એક struct (અથવા interface) ને બીજા struct માં embed કરીને, બાહ્ય પ્રકાર આંતરિક પ્રકારના fields અને methods સીધું મેળવે છે. આ code reuse માટે Go નો જવાબ છે, જે "is-a" વારસાગિરીને બદલે "has-a" composition ને પ્રાધાન્য આપે છે.

## struct embed કરવું

```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 (માત્ર type name લખવું, field name ન હોવું) **promotes** embedded type ના fields અને methods ને બાહ્ય struct માં — તેથી `d.Name` અને `d.Eat()` એવું કામ કરે છે કે જાણે તે `Dog` ને છે. આ વારસાગિરી જેવું લાગે છે પણ composition છે: `Dog` *has an* `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
```

બાહ્ય પ્રકાર એક જ નામનો method વ્યાખ્યાયિત કરી શકે છે પ્રમોટ કરેલ એક ને "override" (shadow) કરવા માટે; તમે હજી પણ embedded version ને explicitly reach કરી શકો છો.

## Interfaces embed કરવું (ખૂબ જ સામાન્ય)

```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 માં compose કરે છે — સમગ્ર standard library માં વપરાય છે.

## Composition over inheritance — Go philosophy

```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 ની **code reuse અને composition** ની વિશિષ્ટ પદ્ધતિ છે, જે મોટાભાગની OOP ભાષાઓમાં મળતી વારસાગિરીને બદલે છે.

તેને સમજવું આવશ્યક છે કારણ કે તે રીતે Go reuse હાંસલ કરે છે (embedded fields/methods ને promote કરીને તેથી બાહ્ય પ્રકાર composition દ્વારા વર્તન "inherit" કરે છે) જ્યારે intentionally વારસાગિરીની જાણીતી સમસ્યાઓને ટાળે છે (fragile base classes, deep rigid hierarchies, tight coupling).

તે વ્યાપક રીતે સમર્થિત સિદ્ધાંત **"composition over inheritance."** ને મૂર્તિમાન કરે છે. Embedding સતત દેખાય છે — reuse માટે structs embed કરવું, મોટા contracts બનાવવા માટે interfaces embed કરવું (જેમ કે `io.ReadWriter`), અને mixin-style વર્તન માટે embedding.

ઓળખવું કે Go માં વારસાગિરી નથી અને embedding તેની compositional વિકલ્પ છે — વધુમાં method-promotion અને shadowing rules — idiomatic Go વાંચવા અને ડિઝાઇન કરવા માટે મૌલિક છે, અને class-based ભાષાઓથી કેટલો અલગ છે તે કારણે સામાન્ય interview topic છે.