Go मध्ये interfaces कसे काम करतात?

Question

Accepted Answer

एक Go **interface** method signatures चा एक संच परिभाषित करते — वर्तनाचा एक करार. महत्त्वाचे म्हणजे, interfaces **अपरिहार्यपणे** समाधानी केल्या जातात: कोणताही प्रकार ज्याला ते methods आहेत तो स्वयंचलितपणे interface समाधानी करतो, **कोणताही स्पष्ट "implements" declaration न करता**. हा 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 नाही — जर प्रकारमध्ये interface चे सर्व methods असतील, तर तो स्वयंचलितपणे interface समाधानी करतो. हे interface त्याच्या implementations पासून decouples करते (लागू करणे कर्ताला 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 सक्षम करतात — वर्तन विरुद्ध कोड लिहा, आणि कोणताही conforming प्रकार काम करतो.

## 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`) कोणताही मूल्य धारण करते — जेव्हा प्रकार अग्रिम पद्धतीने ज्ञात नसतो तेव्हा वापरला जातो (जरी 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 सह काम करते.

## 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 च्या त्याच्या पद्धतीला मध्यभागी आहेत — आणि त्यांचे **अपरिहार्य समाधान** (कोणता `implements` keyword नाही; structural typing) हा भाषेतील सर्वात अलौकिक आणि शक्तिशाली वैशिष्ट्य आहे.

हे decoupling मानतात की types आणि interfaces स्वतंत्रपणे विकसित होतात, तुम्ही interfaces परिभाषित करू शकता *त्यानंतर* types जे त्यांना समाधानी करतात, आणि कोणताही conforming प्रकार interface-आधारित कोड मध्ये स्वयंचलितपणे प्लग करतो — लवचिक, loosely-coupled डिजाइन आणि सहज testing सक्षम करते (mock implementations मध्ये स्वॅप करा).

अपरिहार्य implementation, interfaces द्वारे polymorphism, empty interface/`any`, small-interface idiom ("interfaces स्वीकारा, structs परत करा"), आणि सर्वव्यापी standard-library interfaces (`error`, `io.Reader`/`Writer`, `Stringer`) समजणे हे idiomatic Go साठी आवश्यक आहे.

हे एक वारंवार interview विषय आहे कारण अपरिहार्य, structural मॉडेल Java/C# च्या स्पष्ट interfaces पासून इतके मौलिकपणे वेगळा आहे.

Interface परिभाषित करणे आणि अपरिहार्यपणे लागू करणे

Interfaces द्वारे Polymorphism

Empty interface आणि any

Standard library interfaces ज्या तुम्हाला सतत वापराल

Idiom: interfaces स्वीकारा, structs परत करा

हे महत्त्व का आहे

Empty interface आणि `any`