Go'da arayüzler nasıl çalışır?

Question

Accepted Answer

Bir Go **interface** bir dizi method imzasını tanımlar — bir davranış sözleşmesidir. Çok önemlisi, arayüzler **implicit (dolaylı) olarak** karşılanır: belirtilen method'lara sahip herhangi bir tür otomatik olarak arayüzü karşılar, **açık "implements" bildirimi olmaksızın**. Bu yapısal, duck-typing yaklaşımı karakteristik ve güçlüdür.

## Bir arayüzü tanımlama ve implicit olarak implementasyon

```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` anahtar sözcüğü yoktur — bir tür arayüzün tüm method'larına sahipse, arayüzü otomatik olarak karşılar. Bu, arayüzü implementasyonlarından ayırtır (implementer arayüzün var olduğunu bilmesine bile gerek yoktur).

## Arayüzler aracılığıyla polimorfizm

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

Arayüzler polimorfizmi etkinleştirir — davranışa karşı kod yazın ve uygun herhangi bir tür işe yarar.

## Boş arayüz ve `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
```

Boş arayüz (`interface{}` / `any`) herhangi bir değeri tutar — tür önceden bilinmediği zaman kullanılır (ancak generic'ler artık genellikle bunu yerine alır).

## Sürekli kullanacağınız standart kütüphane arayüzleri

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

Standart kütüphanenin büyük kısmı küçük arayüzler üzerine inşa edilir (`io.Reader`/`io.Writer`, `error`, `Stringer`) — bunları implementasyon yapmak türlerinizi tüm ekosistemle çalışmaya yapar.

## İdiom: arayüzleri kabul edin, struct'ları döndürün

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

## Neden önemli

Arayüzler Go'nun tasarımının merkezinde ve abstraksiyon ile polimorfizme yaklaşımında yer alır — ve bunların **implicit olarak karşılanması** (hiçbir `implements` anahtar sözcüğü yok; yapısal typing), dildeki en karakteristik ve güçlü özelliklerden biridir.

Bu ayırma, türler ve arayüzlerin bağımsız olarak gelişmesini sağlar, arayüzleri bunları karşılayan türlerden *sonra* tanımlayabilirsiniz ve uygun herhangi bir tür arayüz tabanlı koda otomatik olarak bağlanır — esnek, gevşek bağlı tasarımlar ve kolay test etme (mock implementasyonları değiştirin) etkinleştirir.

Implicit implementasyonu, arayüzler aracılığıyla polimorfizmi, boş arayüzü/`any`'i, küçük-arayüz idiomunu ("arayüzleri kabul edin, struct'ları döndürün"), ve her yerde bulunan standart kütüphane arayüzlerini (`error`, `io.Reader`/`Writer`, `Stringer`) anlamak idiomatik Go için gereklidir.

Bu, implicit, yapısal modelin Java/C#'ın açık arayüzlerinden temelde farklı olması nedeniyle sık sık bir mülakat konusudur.

Bir arayüzü tanımlama ve implicit olarak implementasyon

Arayüzler aracılığıyla polimorfizm

Boş arayüz ve any

Sürekli kullanacağınız standart kütüphane arayüzleri

İdiom: arayüzleri kabul edin, struct'ları döndürün

Neden önemli

Boş arayüz ve `any`