இடைமுகங்கள்: ஒரு நடத்தையை வரையறுத்தல்

Go இல் இடைமுகம் என்பது முறை கையொப்பங்களின் தொகுப்பாகும். ஒரு மதிப்பு அனைத்து முறைகளும் இருந்தால் இடைமுகத்தை செயல்படுத்துகிறது - இல்லை implements, இல்லை extends, வெளிப்படையான பதிவு இல்லை. அது மாதிரி பெரும்பாலும் "கட்டமைப்பு தட்டச்சு" அல்லது "நிலையான வாத்து தட்டச்சு" என்று அழைக்கப்படுகிறது: தொகுக்கும் நேரத்தில் கம்பைலர் இணக்கத்தை சரிபார்க்கிறது, ஆனால் அதன் அடிப்படையில் வடிவம், அறிவிப்புகளில் அல்ல.

ஒரு இடைமுகத்தை அறிவிக்கிறது

type Greeter interface {
    Greet() string
}

மாநாடு: ஒற்றை முறை இடைமுகங்களுக்கு -er இல் முடிவடையும் பெயர்கள் (Reader, Writer, Stringer, Closer). சிறிய இடைமுகங்கள் (1-2 முறைகள்) அடையாளம்: நிலையான நூலகம் நிரம்பியுள்ளது ஒன்றாக உருவாக்கும் சிறிய இடைமுகங்கள் (io.ReadWriter, io.ReadCloser, …).

மறைமுகமாக செயல்படுத்துதல்

type Person struct{ Name string }

func (p Person) Greet() string {
    return "ciao " + p.Name
}

// Person satisfies Greeter because it has the required method.
var s Greeter = Person{Name: "Ada"}
fmt.Println(s.Greet())

முக்கிய வார்த்தை இல்லை. வகைக்கு முறைகள் இருந்தால், அதை ஒதுக்கலாம் அந்த இடைமுக வகையின் மாறி. அவ்வளவுதான்.

இடைமுகம் வழியாக பாலிமார்பிசம்

type Robot struct{ ID string }
func (r Robot) Greet() string { return "bip " + r.ID }

func greet(s Greeter) {
    fmt.Println(s.Greet())
}

greet(Person{Name: "Ada"})
greet(Robot{ID: "R2"})

greet Greeter ஐ திருப்திப்படுத்தும் எந்த வகையையும் ஏற்கும். இதுதான் கோ வழி பாலிமார்பிஸம் செய்வது: படிநிலைகள் இல்லை, திறன் மட்டுமே.

வெற்று இடைமுகம்

var x interface{} = 42
var y any = "ciao"   // any is the built-in alias of interface{}

interface{} (அல்லது any முதல் கோ 1.18) எந்த முறைகளும் தேவையில்லை, அதனால் ஏதேனும் மதிப்பு அதை திருப்திப்படுத்துகிறது. பொதுவான கொள்கலன்களுக்கு பயனுள்ளதாக இருக்கும், ஆனால் பிரித்தெடுக்க உங்களுக்கு தேவையான உறுதியான மதிப்பு வகை வலியுறுத்தல் அல்லது வகை சுவிட்ச் (அடுத்த பாடங்கள்).

முறை தொகுப்பு: மதிப்பு vs சுட்டி ரிசீவர் (முன்னோட்டம்)

தொகுதி 5 இலிருந்து திரும்ப அழைக்கவும்:

• மதிப்பு பெறுதல் கொண்ட முறைகள் T மற்றும் *T இரண்டின் முறை தொகுப்பில் உள்ளன.
• சுட்டி ரிசீவர் கொண்ட முறைகள் *T இன் முறை தொகுப்பில் மட்டுமே உள்ளன.

நடைமுறை விளைவு:

type Counter struct{ N int }
func (c *Counter) Inc() { c.N++ }

type Incrementer interface { Inc() }

var i Incrementer = &Counter{}   // OK: *Counter has Inc()
// var j Incrementer = Counter{} // ERROR: Counter (value) does NOT

ஒரு முறைக்கு ஒரு சுட்டி ரிசீவர் இருந்தால், நீங்கள் ஒரு சுட்டியை ஒதுக்க வேண்டும் இடைமுக மாறி.

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

type P struct{}
// ?

மறுபரிசீலனை

• இடைமுகம் = முறை கையொப்பங்களின் தொகுப்பு; இல்லை implements.
• மறைமுகமான செயல்படுத்தல்: சரியான கையொப்பத்துடன் முறைகளை வைத்திருங்கள்.
• மொழியியல்: சிறிய இடைமுகங்கள் (1–2 முறைகள்), -er இல் உள்ள பெயர்கள்.
• interface{} / any: எந்த மதிப்பையும் ஏற்றுக்கொள்கிறது, வகை பாதுகாப்பை இழக்கிறது.
• முறை தொகுப்பு: பாயிண்டர் ரிசீவர் → மட்டும் *T இடைமுகத்தை திருப்திப்படுத்துகிறது.
• கோ பாலிமார்பிசம்: இடைமுகம்-தட்டப்பட்ட அளவுருக்கள், படிநிலைகள் இல்லை.