Kaip veikia sąsajos (interfaces) Go?

Question

Accepted Answer

Go **sąsaja** (interface) apibrėžia metodų signatūrų rinkinį — elgesio sutartį. Labai svarbu, kad sąsajos yra tenkinamos **netiesiogiai**: bet koks tipas, kuris turi tuos metodus, automatiškai tenkina sąsają, **be jokios aiškios "implements" deklaracijos**. Šis struktūrinis, duck-typing požiūris yra savitai ir galingas.

## Sąsajos apibrėžimas ir neteisioginė realizacija

```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"
```

Nėra jokio `implements` raktažodžio — jei tipas turi visus sąsajos metodus, jis automatiškai ją tenkina. Tai atskyrimas sąsają nuo jos realizacijų (realizuotojas netgi neturi žinoti apie sąsajos egzistavimą).

## Polimorfizmas per sąsajas

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

Sąsajos įgalina polimorfizmą — rašykite kodą pagal elgesį, ir bet koks atitinkantis tipas veiks.

## Tuščia sąsaja ir `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
```

Tuščia sąsaja (`interface{}` / `any`) gali turėti bet kokią reikšmę — naudojama, kai tipas iš anksto nežinomas (nors dabar generikai dažnai ją pakeičia).

## Standartinės bibliotekos sąsajos, kurias nuolat naudosite

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

Didelė standartinės bibliotekos dalis yra pagrįsta mažomis sąsajomis (`io.Reader`/`io.Writer`, `error`, `Stringer`) — jų realizavimas padaro jūsų tipus suderinamus su visa ekosistema.

## Idioma: priimkite sąsajas, grąžinkite struktūras

```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."
```

## Kodėl tai svarbu

Sąsajos yra svarbios Go dizainui ir jo požiūriui į abstrakcijas bei polimorfizmą — ir jų **neteisioginė realizacija** (be `implements` raktažodžio; struktūrinis tipizavimas) yra viena iš labiausiai išskirčių ir galingiausių kalbos savybių.

Šis atskyrimas reiškia, kad tipai ir sąsajos besivystančios nepriklausomai, galite apibrėžti sąsajas *po* tipų, kurie jas tenkina, ir bet koks atitinkantis tipas automatiškai prijungiamas prie sąsajomis pagrįsto kodo — sudarydamas lanksčius, laisvai sujungtus dizzinus ir lengvą testavimą (pakeiskite į mock realizacijas).

Supratimas apie netiesioginę realizaciją, polimorfizmą per sąsajas, tuščią sąsają/`any`, mažų sąsajų idiomą ("priimkite sąsajas, grąžinkite struktūras") ir visur esančias standartinės bibliotekos sąsajas (`error`, `io.Reader`/`Writer`, `Stringer`) yra neatsiejamas idiomatinio Go dalis.

Tai dažnas interviu klausimas tiksliai dėl to, kad neteisioginį, struktūrinį modelį iš esmės skiriasi nuo aiškių Java/C# sąsajų.

Sąsajos apibrėžimas ir neteisioginė realizacija

Polimorfizmas per sąsajas

Tuščia sąsaja ir any

Standartinės bibliotekos sąsajos, kurias nuolat naudosite

Idioma: priimkite sąsajas, grąžinkite struktūras

Kodėl tai svarbu

Tuščia sąsaja ir `any`