Go ਵਿੱਚ interfaces ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

A Go **interface** method signatures ਦਾ ਇੱਕ ਸੈੱਟ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ — ਵਿਵਹਾਰ ਦਾ ਇੱਕ ਕਰਾਰ। ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਤੇ, interfaces **ਬਿਨਾਂ ਸਪਸ਼ਟ ਤਰੀਕੇ ਨਾਲ** ਸੰਤੁਸ਼ਟ ਹੁੰਦੇ ਹਨ: ਕੋਈ ਵੀ type ਜਿਸ ਕੋਲ ਉਹ methods ਹਨ, ਆਪਣੇ ਆਪ ਹੀ interface ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ, **ਕੋਈ ਸਪਸ਼ਟ "implements" ਘੋਸ਼ਣਾ ਨਾਲ ਬਿਨਾਂ**। ਇਹ structural, duck-typing ਪਹੁੰਚ ਵਿਸ਼ੇਸ਼ ਅਤੇ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੈ।

## Interface ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਅਤੇ ਬਿਨਾਂ ਸਪਸ਼ਟਤਾ ਨਾਲ implement ਕਰਨਾ

```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 ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦੇ ਹਨ — ਵਿਵਹਾਰ ਦੇ ਵਿਰੁੱਧ ਕੋਡ ਲਿਖੋ, ਅਤੇ ਕੋਈ ਵੀ conforming 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`) ਤੇ ਬਣੀ ਹੈ — ਇਨ੍ਹਾਂ ਨੂੰ implement ਕਰਨ ਨਾਲ ਤੁਹਾਡੀਆਂ types ਪੂਰੇ ecosystem ਨਾਲ ਕੰਮ ਕਰਦੀਆਂ ਹਨ।

## ਮੁਹਾਵਰਾ: 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 ਆਜ਼ਾਦੀ ਨਾਲ ਵਿਕਸਤ ਹੁੰਦੇ ਹਨ, ਤੁਸੀਂ types ਦੇ ਬਾਅਦ interfaces ਦਿਖਾ ਸਕਦੇ ਹੋ ਜੋ ਉਨ੍ਹਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਹਨ, ਅਤੇ ਕੋਈ ਵੀ conforming type interface-based ਕੋਡ ਵਿੱਚ ਪਲੱਗ ਇਨ ਹੁੰਦਾ ਹੈ — flexible, loosely-coupled ਡਿਜ਼ਾਈਨ ਅਤੇ ਆਸਾਨ ਟੈਸਟਿੰਗ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ (mock implementations ਨੂੰ swap ਕਰੋ)।

Implicit implementation, interfaces ਦੇ ਜ਼ਰੀਏ polymorphism, empty interface/`any`, ਛੋਟੇ-interface ਮੁਹਾਵਰਾ ("interfaces ਨੂੰ ਸਵੀਕਾਰ ਕਰੋ, structs ਵਾਪਸ ਕਰੋ"), ਅਤੇ ਸਰਵ-ਵਿਆਪਕ standard-library interfaces (`error`, `io.Reader`/`Writer`, `Stringer`) ਨੂੰ ਸਮਝਨਾ idiomatic Go ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

ਇਹ ਇੱਕ ਵਾਰ-ਵਾਰ ਇੰਟਰਵਿਊ ਵਿਸ਼ਾ ਹੈ ਕਿਉਂਕਿ implicit, structural ਮਾਡਲ Java/C# ਦੀਆਂ ਸਪਸ਼ਟ interfaces ਤੋਂ ਬਿਲਕੁਲ ਵੱਖਰਾ ਹੈ।

Interface ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਅਤੇ ਬਿਨਾਂ ਸਪਸ਼ਟਤਾ ਨਾਲ implement ਕਰਨਾ

Interfaces ਦੇ ਜ਼ਰੀਏ Polymorphism

Empty interface ਅਤੇ any

Standard library interfaces ਜਿਨ੍ਹਾਂ ਦਾ ਤੁਸੀਂ ਲਗਾਤਾਰ ਵਰਤੋਂ ਕਰੋਂਗੇ

ਮੁਹਾਵਰਾ: interfaces ਨੂੰ ਸਵੀਕਾਰ ਕਰੋ, structs ਵਾਪਸ ਕਰੋ

ਇਸ ਦੀ ਮਹੱਤਤਾ

Empty interface ਅਤੇ `any`