Go માં interfaces કેવી રીતે કાર્ય કરે છે?

Question

Accepted Answer

Go **interface** પદ્ધતિ સહીનીઓનો સમૂહ વ્યાખ્યાયિત કરે છે — વર્તણૂકનો એક કરાર. મહત્ત્વનું હતું કે, interfaces **સંપૂર્ણપણે સંતુષ્ટ** છે: કોઈપણ પ્રકાર જેની પાસે તે પદ્ધતિઓ છે તે તરત જ interface ને સંતુષ્ટ કરે છે, **કોઈ સ્પષ્ટ "implements" જાહેરાત વિના**. આ માળખાકીય, 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` કીવર્ડ નથી — જો પ્રકારની પાસે interface ની બધી પદ્ધતિઓ હોય તો તે તરત જ interface ને સંતુષ્ટ કરે છે. આ interface ને તેના અમલીકરણથી અલગ કરે છે (અમલીકરણને 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 સક્ષમ કરે છે — વર્તણૂક વિરુદ્ધ કોડ લખો, અને કોઈપણ અનુરૂપ પ્રકાર કાર્ય કરે છે.

## ખાલી 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
```

ખાલી interface (`interface{}` / `any`) કોઈપણ મૂલ્ય ધરાવે છે — જ્યારે પ્રકાર અગાઉથી જાણવામાં આવતો નથી તે સમયે ઉપયોગ થાય છે (જોકે generics હવે ઘણીવાર આનો સ્થાન લે છે).

## પ્રમાણભૂત પુસ્તકાલય 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) }
```

પ્રમાણભૂત પુસ્તકાલયનો મોટાભાગ નાના interfaces પર બનેલો છે (`io.Reader`/`io.Writer`, `error`, `Stringer`) — તેમને અમલમાં મૂકવું તમારા પ્રકારોને સમગ્ર ઇકોસિસ્ટમ સાથે કાર્ય કરે છે.

## ભાષા: 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 ના ડિઝાઇનમાં કેન્દ્રીય છે અને તેનો અમૂર્તતા અને polymorphism ના અભિગમમાં — અને તેમની **સંપૂર્ણ સંતુષ્ટિ** (`implements` કીવર્ડ નથી; માળખાકીય ટાઇપિંગ) ભાષામાં સૌથી અલગ અને શક્તિશાળી સુવિધાઓમાંની એક છે.

આ અલગતા એટલે કે પ્રકાર અને interfaces સ્વતંત્ર રીતે વિકસિત થાય છે, તમે અમલીકરણ કરતા પ્રકારો *પછી* interfaces વ્યાખ્યાયિત કરી શકો છો, અને કોઈપણ અનુરૂપ પ્રકાર interface-આધારિત કોડમાં તરત જ જોડાય છે — લવચક, ढીલું-સંકલિત ડિઝાઇન અને સરળ પરીક્ષણ (મોક અમલીકરણો સ્વેપ કરો) સક્ષમ કરે છે.

સંપૂર્ણ અમલીકરણ, interfaces તરીકે polymorphism, ખાલી interface/`any`, નાના-interface ભાષા ("interfaces સ્વીકારો, structs પાછું કરો"), અને સર્વવ્યાપી પ્રમાણભૂત-પુસ્તકાલય interfaces (`error`, `io.Reader`/`Writer`, `Stringer`) સમજવું આદર્શ Go ની આવશ્યકતા છે.

સાક્ષાત્કાર વિષય તરીકે ઘણીવાર આવે છે કારણ કે સંપૂર્ણ, માળખાકીય મોડેલ Java/C# ના સ્પષ્ટ interfaces થી બિલકુલ અલગ છે.

Interface ને વ્યાખ્યાયિત કરવું અને સંપૂર્ણપણે અમલ કરવું

Interfaces તરીકે Polymorphism

ખાલી interface અને any

પ્રમાણભૂત પુસ્તકાલય interfaces જે તમે સતત ઉપયોગ કરશો

ભાષા: interfaces સ્વીકારો, structs પાછું કરો

શા માટે તે મહત્ત્વપૂર્ણ છે

ખાલી interface અને `any`