Go में interfaces कैसे काम करते हैं?

Question

Accepted Answer

एक Go **interface** method signatures का एक सेट परिभाषित करता है — व्यवहार का एक अनुबंध। महत्वपूर्ण बात यह है कि interfaces **अंतर्निहित रूप से (implicitly)** संतुष्ट होते हैं: कोई भी type जिसमें वे methods हों स्वतः interface को संतुष्ट करता है, **कोई स्पष्ट "implements" घोषणा** नहीं। यह structural, duck-typing दृष्टिकोण विशिष्ट और शक्तिशाली है।

## एक 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 नहीं है — यदि किसी type में interface के सभी methods हैं, तो वह स्वतः interface को संतुष्ट करता है। यह interface को उसके implementations से अलग कर देता है (implementer को यह जानने की ज़रूरत भी नहीं कि 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 सक्षम करते हैं — व्यवहार के विरुद्ध code लिखें, और कोई भी अनुरूप type काम करता है।

## 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`) कोई भी value रखता है — तब उपयोग होता है जब 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`) पर बना है — इन्हें लागू करने से आपके types पूरे ecosystem के साथ काम करते हैं।

## मुहावरा: accept interfaces, return 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 के design और abstraction व polymorphism के प्रति इसके दृष्टिकोण के केंद्र में हैं — और इनकी **अंतर्निहित संतुष्टि** (कोई `implements` keyword नहीं; structural typing) भाषा की सबसे विशिष्ट और शक्तिशाली विशेषताओं में से एक है।

यह decoupling मतलब types और interfaces स्वतंत्र रूप से विकसित होते हैं, आप उन types के *बाद* interfaces परिभाषित कर सकते हैं जो उन्हें संतुष्ट करते हैं, और कोई भी अनुरूप type interface-based code में स्वतः जुड़ जाता है — जो लचीले, ढीले-युग्मित designs और आसान testing (mock implementations को swap करना) सक्षम करता है।

implicit implementation, interfaces के माध्यम से polymorphism, empty interface/`any`, small-interface मुहावरा ("accept interfaces, return structs"), और सर्वव्यापी standard-library interfaces (`error`, `io.Reader`/`Writer`, `Stringer`) को समझना idiomatic Go के लिए आवश्यक है।

यह एक बार-बार आने वाला interview विषय है ठीक इसलिए क्योंकि implicit, structural मॉडल Java/C# के explicit interfaces से इतना मौलिक रूप से भिन्न है।

एक interface परिभाषित करना और अंतर्निहित रूप से लागू करना

interfaces के माध्यम से polymorphism

empty interface और any

standard library interfaces जिन्हें आप लगातार उपयोग करेंगे

मुहावरा: accept interfaces, return structs

यह क्यों महत्वपूर्ण है

empty interface और `any`