Conas a oibríonn comhéadain i Go?

Question

Accepted Answer

Sainíonn Go **comhéadan** (interface) sraith síoróga modhanna — conradh iompraíochta. Ar an tslí chriticiúil, bíonn comhéadain sásta **go intuigthe**: aon chineál a bhfuil na modhanna sin air a sháraíonn an comhéadan go huathoibríoch, gan aon dearbhú follasach "implements". Tá an cur chuige struchtúrtha seo, atá cosúil le duck-typing, sainiúil agus cumhachtach.

## Comhéadain a shainiú agus a chur i bhfeidhm go intuigthe

```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íl aon eochairfhocal `implements` ann — má bhíonn aon chineál fhoirmithe ag gach ceann de mhodhanna an chomhéadain, sásaítear an comhéadan go huathoibríoch. Scoiltear an comhéadan ó a chur i bhfeidhm (ní gá do thí a chur i bhfeidhm go fios a bheith aici go bhfuil an comhéadan ann fiú).

## Iltéagarú trí chomhéadain

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

Ceadaíonn comhéadain iltéagarú — scríobh cód i gcoinne an iompraíochta, agus oibríonn aon chineál atá comhiomlán.

## An comhéadan folamh agus `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
```

Tógann an comhéadan folamh (`interface{}` / `any`) aon luach — úsáidtear é nuair nach bhíonn an cineál ar eolas roimh ama (cé go bhfuil generics in ionad air anois de ghnáth).

## Comhéadain leabharlann caighdeánach a úsáidfidh tú i rith an ama

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

Tógtar a lán den leabharlann caighdeánach ar chomhéadain beaga (`io.Reader`/`io.Writer`, `error`, `Stringer`) — má chuireann tú iad i bhfeidhm, oibríonn do chineálacha leis an sprioc ar fad.

## An nós imeachta: glacadh le comhéadain, aiseolas a dhéanamh ar 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."
```

## Cén fáth a bhfuil sé tábhachtach

Tá comhéadain i gcrích dearadh Go agus a cur chuige ar astarraingt agus ar iltéagarú — agus is é a **sásúchán intuigthe** (gan eochairfhocal `implements`; scríofa struchtúrtha) ceann de na gné is sainiúla agus is cumhachtaí sa teanga.

Ciallaonn an scoilt seo go bhfás cineálacha agus comhéadain go neamhspleách, is féidir leat comhéadain a shainiú *tar éis* na cineálacha a bhíonn sásta iontu, agus ceanglaíonn aon chineál a bhíonn comhiomlán sé isteach go huathoibríoch i gcód bunaithe ar chomhéadain — ag soláthru dearaí foluain agus neamhdhlúth, agus tástáil throm (gealadh cur i bhfeidhm níos geal).

Is ríthábhachtach a thuiscint sásúchán intuigthe, iltéagarú trí chomhéadain, an comhéadan folamh/`any`, an nós beag-chomhéadan ("glacadh le comhéadain, aiseolas a dhéanamh ar structs"), agus na comhéadain leabharlann caighdeánach go fairsing (`error`, `io.Reader`/`Writer`, `Stringer`) do Go idiomatic.

Is topaicdhírithe agallamh ar leith í toisc go raibh an tsamhail thuigthe, struchtúrtha seo chomh difriúil sin ó na comhéadain follasacha de Java/C#.

Comhéadain a shainiú agus a chur i bhfeidhm go intuigthe

Iltéagarú trí chomhéadain

An comhéadan folamh agus any

Comhéadain leabharlann caighdeánach a úsáidfidh tú i rith an ama

An nós imeachta: glacadh le comhéadain, aiseolas a dhéanamh ar structs

Cén fáth a bhfuil sé tábhachtach

An comhéadan folamh agus `any`