Hvordan virker interfaces i Go?

Question

Accepted Answer

En Go **interface** definerer et sæt metodesignaturer — en kontrakt for adfærd. Afgørende er, at interfaces bliver opfyldt **implicit**: enhver type der har disse metoder opfylder automatisk interfacet, **uden nogen eksplicit "implements"-erklæring**. Denne strukturelle, duck-typing-tilgang er karakteristisk og kraftfuld.

## Definition og implicit implementering af et 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"
```

Der er intet `implements`-nøgleord — hvis en type har alle interfacets metoder, opfylder den interfacet automatisk. Dette afkoblet interfacet fra dets implementeringer (implementøren behøver ikke engang at kende til interfacets eksistens).

## Polymorfi gennem 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 muliggør polymorfi — skriv kode mod adfærden, og enhver passende type virker.

## Det tomme interface og `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
```

Det tomme interface (`interface{}` / `any`) kan holde enhver værdi — bruges når typen ikke er kendt på forhånd (selvom generics nu ofte erstatter dette).

## Standard library-interfaces du bruger konstant

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

Megaparten af standard library er bygget på små interfaces (`io.Reader`/`io.Writer`, `error`, `Stringer`) — at implementere dem gør dine typer kompatible med hele økosystemet.

## Idiomatikken: accepter interfaces, returner 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."
```

## Hvorfor det betyder noget

Interfaces er centrale for Gos design og dets tilgang til abstraktion og polymorfi — og deres **implicitte opfyldelse** (intet `implements`-nøgleord; strukturel typning) er en af de mest karakteristiske og kraftfulde funktioner i sproget.

Denne afkobling betyder, at typer og interfaces udvikler sig uafhængigt, du kan definere interfaces *efter* de typer der opfylder dem, og enhver passende type tilsluttes automatisk til interface-baseret kode — hvilket muliggør fleksible, løst koblede designs og nem testing (udskift med mock-implementeringer).

At forstå implicit implementering, polymorfi via interfaces, det tomme interface/`any`, small-interface-idiomatikken ("accepter interfaces, returner structs"), og de allestedsnærværende standard library-interfaces (`error`, `io.Reader`/`Writer`, `Stringer`) er essentielt for idiomatisk Go.

Det er et hyppigt interviewemne netop fordi den implicitte, strukturelle model adskiller sig så fundamentalt fra de eksplicitte interfaces i Java/C#.

Definition og implicit implementering af et interface

Polymorfi gennem interfaces

Det tomme interface og any

Standard library-interfaces du bruger konstant

Idiomatikken: accepter interfaces, returner structs

Hvorfor det betyder noget

Det tomme interface og `any`