Interfaces suna aiki ta yaya a Go?

Question

Accepted Answer

Go **interface** yana bayyana saitin siginar hanyoyi — kwangila game da hali. A mahimmanci, interfaces suna gamsuwa **jiya jiya**: wani nau'i daya wanda ke da waɗannan hanyoyi yana gamsar interface ba tare da bayyanannen bayanin "implements" ba. Wannan tsarin tsarin jiki, nawa-typing nuni shine musamman kuma mai iko.

## Siffanta da aiwatar jiya jiya akan 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"
```

Babu kalmar `implements` — idan nau'i yana da dukan hanyoyi na interface, yana gamsar interface jiya jiya. Wannan yana raba interface daga aiwatarsa (mai aiwata bai bugi kuma ba don sanin interface ta wanzu).

## Polymorphism ta hanyar interfaces

```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 suna ba da damar polymorphism — rubuta lambar da hali, kuma wani nau'i daya daidaita aiki.

## Interface mai coofo da `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 mai coofo (`interface{}` / `any`) yana riƙe da wani kima - ana amfani da shi lokacin da ba a san nau'in gaba ido (kodayake generics yanzu galibi suna maye gurbin wannan).

## Interfaces na aiki gida wanda kana ba da amfani sosai

```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) }
```

Yawancin aiki gida shine gina akan ƙananan interfaces (`io.Reader`/`io.Writer`, `error`, `Stringer`) — aiwatar su yana sa nau'an ku aiki tare da dukan ecosystem.

## Kula: yawaita interfaces, mayar da 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."
```

## Dalilin da ya dace

Interfaces sune tsakiya ga tsarin Go da tsarin sa na abstraction da polymorphism — kuma su **gamsuwa jiya jiya** (babu kalmar `implements`; tsarin tsarin) shine daya daga mafi musamman kuma maimacon abubuwa a cikin harshe.

Wannan raba yana nufin nau'an da interfaces suna tasowa jiya jiya, kana iya siffanta interfaces *bayan* nau'in da ke gamsar su, kuma wani nau'i daidaita yana tushe cikin lambar tushen interface jiya jiya — yana ba da damar designs na maƙausa, lassai da sauƙi, da gwaji mai sauƙi (sauya cikin aiwatarsa mai lalata).
": ganewa jiya jiya, polymorphism ta hanyar interfaces, interface mai coofo/`any`, kula-interface idiom ("yawaita interfaces, mayar da structs"), kuma interfaces na aiki gida da keɓance-keɓance (`error`, `io.Reader`/`Writer`, `Stringer`) shine dole don idiomatic Go.

Wannan bai ba da katuwa na tattaunawa saboda jiya jiya, tsarin tsarin yana kaiwa da bayyanannen interfaces na Java/C# ba.

Siffanta da aiwatar jiya jiya akan interface

Polymorphism ta hanyar interfaces

Interface mai coofo da any

Interfaces na aiki gida wanda kana ba da amfani sosai

Kula: yawaita interfaces, mayar da structs

Dalilin da ya dace

Interface mai coofo da `any`