Go-ல் interfaces எவ்வாறு செயல்படுகின்றன?

Question

Accepted Answer

ஒரு Go **interface** method signatures-களின் ஒரு தொகுப்பை வரையறுக்கிறது — நடத்தையின் ஒரு ஒப்பந்தம். முக்கியமாக, interfaces **மறைமுகமாக** திருப்திப்படுத்தப்படுகின்றன: அந்த முறைகளைக் கொண்ட எந்த வகையும் தானாக interface ஐ திருப்திப்படுத்துகிறது, **"implements" வெளிப்படையான அறிவிப்பு இல்லை**. இந்த structural, duck-typing அணுகுமுறை distinctive மற்றும் சக்திशાली.

## Interface வரையறுத்தல் மற்றும் மறைமுகமாக செயல்படுத்துதல்

```go
// define an interface — a set of method signatures
type Speaker interface {
    Speak() string
}

type Dog struct{}
func (d Dog) Speak() string { return "Woof" }   // Dog has Speak() → it IS a Speaker

type Cat struct{}
func (c Cat) Speak() string { return "Meow" }   // Cat too — implicitly

// NO "implements Speaker" anywhere — satisfaction is automatic
var s Speaker = Dog{}    // works because Dog has the Speak() method
s.Speak()                // "Woof"
```

`implements` keyword இல்லை — ஒரு வகையில் interface-ல் உள்ள அனைத்து methods இருந்தால், அது தானாக interface ஐ திருப்திப்படுத்துகிறது. இது interface ஐ அதன் implementations-ல் இருந்து பிரிக்கிறது (செயல்படுத்துபவர் interface வெகு தொலைவில் இருப்பதை கூட தெரிந்து கொள்ள வேண்டியதில்லை).

## Interfaces மூலம் polymorphism

```go
func announce(s Speaker) {        // accepts ANY type that has Speak()
    fmt.Println(s.Speak())
}
announce(Dog{})    // "Woof"
announce(Cat{})    // "Meow"

speakers := []Speaker{Dog{}, Cat{}}   // a slice of different types via the interface
for _, sp := range speakers { sp.Speak() }
```

Interfaces polymorphism ஐ செயல்படுத்துகின்றன — நடத்தைக்கு எதிராக குறியீட்டை எழுதுங்கள், மற்றும் எந்த சামஞ்சஸ்ய வகையும் செயல்படுகிறது.

## Empty interface மற்றும் `any`

```go
var x interface{}     // the empty interface — satisfied by EVERY type (no methods required)
x = 42
x = "hello"
// Go 1.18+: `any` is an alias for interface{}
func print(v any) { fmt.Println(v) }   // accepts anything
```

Empty interface (`interface{}` / `any`) எந்த மதிப்பையும் வைத்திருக்கிறது — type முன்கூட்டியே தெரியாதபோது பயன்படுத்தப்படுகிறது (generics இப்போது பெரும்பாலும் இதை மாற்றுகிறது).

## நீங்கள் சதா பயன்படுத்தும் standard library interfaces

```go
type Stringer interface { String() string }   // controls fmt printing
type error interface { Error() string }        // the error type itself!
type io.Reader interface { Read(p []byte) (n int, err error) }
type io.Writer interface { Write(p []byte) (n int, err error) }
```

Standard library பெரும்பாலும் சிறிய interfaces-ல் கட்டமைக்கப்பட்டுள்ளது (`io.Reader`/`io.Writer`, `error`, `Stringer`) — அவற்றை செயல்படுத்துவது உங்கள் வகைகளை முழு ecosystem உடன் செயல்பட வைக்கிறது.

## Idiom: interfaces ஐ ஏற்று, structs திரும்பி கொடு

```text
Go favors SMALL interfaces (often one method) defined where they're USED (the consumer),
not where types are defined. "The bigger the interface, the weaker the abstraction."
```

## இது ஏன் முக்கியமானது

Interfaces Go-ல் வடிவமைப்பிற்கு மற்றும் abstraction மற்றும் polymorphism-க்கான அணுகுமுறைக்கு மையமாக உள்ளன — மற்றும் அவற்றின் **mறைமுக திருப்தி** (`implements` keyword இல்லை; structural typing) மொழியில் மிகவும் distinctive மற்றும் சக்திšালி features-களில் ஒன்றாகும்.

இந்த decoupling என்பது types மற்றும் interfaces சுயாதீனமாக evolved ஆகின்றன, நீங்கள் interface வரையறுக்க முடியும் *அதன் பிறகு* அவற்றை திருப்திப்படுத்தும் types, மற்றும் எந்த சামஞ்சஸ்ய வகையும் interface-based குறியீட்டிற்கு தானாக plug in ஆகிறது — liuyvy loosely-coupled designs மற்றும் சுலபமான testing ஐ செயல்படுத்துகிறது (mock implementations ஐ swap in செய்யுங்கள்).

Mறைமுக implementation, interfaces மூலம் polymorphism, empty interface/`any`, சிறிய-interface idiom ("accept interfaces, return structs"), மற்றும் ubiquitous standard-library interfaces (`error`, `io.Reader`/`Writer`, `Stringer`) அரண்டினை புரிந்து கொள்வது idiomatic Go க்கு அপরिहार्य.

இது ஒரு படிக்க அடிக்கடி interview topic ஆகும் ஏனெனில் mறைமுक, structural model Java/C#-ல் இருந்து explicit interfaces-ல் இருந்து அடிப்படையாக வேறுபட்டுள்ளது.

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

Interfaces மூலம் polymorphism

Empty interface மற்றும் any

நீங்கள் சதா பயன்படுத்தும் standard library interfaces

Idiom: interfaces ஐ ஏற்று, structs திரும்பி கொடு

இது ஏன் முக்கியமானது

Empty interface மற்றும் `any`