கலவை (உட்பொதித்தல்)

போ பரம்பரை இல்லை. மறுபயன்பாடு என்பதற்கு இடியோடிக் பதில் ** கலவை**, மற்றும் குறிப்பாக ** உட்பொதித்தல்**: ஒரு வகை உட்பட புலம் பெயர் கொடுக்காமல் இன்னொன்றின் உள்ளே. துறைகள் மற்றும் முறைகள் உட்பொதிக்கப்பட்ட வகையானது மேம்படுத்தப்படும், நேரடியாக அணுகக்கூடியதாக மாறும் அவை வெளி வகையைச் சேர்ந்தவை.

கட்டமைப்பு உட்பொதித்தல்

type Animal struct {
    Name string
}

func (a Animal) Greet() string {
    return "ciao da " + a.Name
}

type Dog struct {
    Animal        // embedding — NO field name
    Breed string
}

c := Dog{
    Animal: Animal{Name: "Rex"},
    Breed:  "Pastore",
}

fmt.Println(c.Name)         // "Rex" — promoted from Animal
fmt.Println(c.Greet())      // "ciao da Rex" — promoted method
fmt.Println(c.Breed)        // own field

உட்பொதிக்கப்பட்ட புலத்தை இன்னும் வகையின் பெயரால் அணுகலாம்: c.Animal.Name வேலை செய்கிறது மற்றும் c.Name ஐ ஒத்திருக்கிறது. அது எப்போது தேவைப்படுகிறது மோதல்கள் உள்ளன.

புறக்கணிப்பு (பகுதி): முறை "நிழல்"

வெளிப்புற வகை, பதவி உயர்வு பெற்ற அதே பெயரில் ஒரு முறையை வரையறுத்தால் ஒன்று, அதன் முறை "வெற்றி". உள்ளே இருந்து நீங்கள் எப்போதும் உட்பொதிக்கப்பட்ட இடத்தை அடையலாம் வகையின் பெயர் வழியாக ஒன்று:

func (c Dog) Greet() string {
    return "BAU! " + c.Animal.Greet()
}

இது பாலிமார்பிக் பரம்பரை அல்ல: இது வெறும் லெக்சிக்கல் பெயர் தீர்மானம். பாலிமார்பிஸத்திற்கு நீங்கள் ** இடைமுகங்களைப் பயன்படுத்துகிறீர்கள்** (தொகுதி 6).

பல உட்பொதித்தல்

நீங்கள் பல வகைகளை உட்பொதிக்கலாம்:

type Logger struct{ /*...*/ }
func (l Logger) Log(msg string) { /*...*/ }

type Timer struct{ /*...*/ }
func (t Timer) Now() time.Time { /*...*/ }

type Service struct {
    Logger
    Timer
    Name string
}

s := Service{Name: "api"}
s.Log("start")   // promoted from Logger
s.Now()          // promoted from Timer

உட்பொதிக்கப்பட்ட இரண்டு வகைகளுக்கு ஒரே பெயரில் ஒரு முறை இருந்தால், நேரடி அணுகல் தெளிவற்றதாக மாறும் மற்றும் தொகுப்பிக்கு வெளிப்படையான வடிவம் தேவைப்படுகிறது (s.Logger.Foo() அல்லது s.Timer.Foo()).

இடைமுகம் உட்பொதித்தல்

இடைமுகங்களும் "உட்பொதிக்கப்பட்டவை" (தொகுதி 6 ஐப் பார்க்கவும்):

type ReadWriter interface {
    io.Reader
    io.Writer
}

இது Reader மற்றும் Writer இன் முறைகளின் ஒன்றியத்திற்குச் சமம்.

வெளிப்படையான கலவையை எப்போது பயன்படுத்த வேண்டும் (உட்பொதிக்கவில்லை)

நீங்கள் பெயரிடப்பட்ட புலம் மற்றும் தானியங்கு-விளம்பரம் இல்லை எனில், எளியதைப் பயன்படுத்தவும் கலவை:

type Dog struct {
    Anim  Animal    // NORMAL field, no promotion
    Breed string
}
c.Anim.Name   // you need the field name

உட்பொதித்தல் என்பது எளிதான ** பிரதிநிதித்துவக் கருவி**, வடிவமைப்புத் தேர்வு அல்ல வெளிப்படையான கலவையை விட கண்டிப்பாக சிறந்தது: நீங்கள் உண்மையிலேயே விரும்பும் போது அதைப் பயன்படுத்தவும் உள் வகையின் API ஐ விளம்பரப்படுத்த.

முயற்சி செய்து பாருங்கள்

type B struct { /* extends A? */ }

மறுபரிசீலனை

• பரம்பரை இல்லை: நீங்கள் உட்பொதித்தல் மூலம் எழுதுகிறீர்கள்.
• உட்பொதித்தல் = struct இல் புலம் பெயர் இல்லாமல் TYPE ஐ எழுதுதல்.
• உட்பொதிக்கப்பட்ட வகையின் புலங்கள் மற்றும் முறைகள் மேம்படுத்தப்படும்.
• வெளிப்படையான அணுகல் எப்போதும் கிடைக்கும்: outer.Inner.Field.
• "லெக்சிகல்" மேலெழுதுதல்: வெளிப்புற வகையின் முறை விளம்பரப்படுத்தப்பட்டதை நிழலாடுகிறது.
• உட்பொதித்தல் ≠ என்பது-a: பாலிமார்பிஸத்திற்கு இடைமுகங்களைப் பயன்படுத்துதல்.