Hur fungerar interfaces i Go?

Question

Accepted Answer

Ett Go **interface** definierar en uppsättning metodsignaturer — ett kontakt för beteende. Avgörande är att interfaces är uppfyllda **implicit**: alla typer som har dessa metoder uppfyller automatiskt interfacet, med **ingen explicit "implements"-deklaration**. Denna strukturella, duck-typing-approach är distinktiv och kraftfull.

## Definition och implicit implementering av ett 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"
```

Det finns ingen `implements`-nyckelord — om en typ har alla interfaceMetoder uppfyller den interfacet automatiskt. Detta frikopplar interfacet från dess implementeringar (implementeraren behöver inte ens veta att interfacet finns).

## Polymorfism genom 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 möjliggör polymorfism — skriv kod mot beteendet, och alla överensstämmande typer fungerar.

## Det tomma interfacet och `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 tomma interfacet (`interface{}` / `any`) kan innehålla vilket värde som helst — används när typen inte är känd i förväg (även om generics ofta ersätter detta nu).

## Standard library-interfaces du använder 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) }
```

Mycket av standardbiblioteket är byggt på små interfaces (`io.Reader`/`io.Writer`, `error`, `Stringer`) — genom att implementera dem gör du dina typer kompatibla med hela ekosystemet.

## Idiomen: acceptera interfaces, returnera 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."
```

## Varför det spelar roll

Interfaces är centrala för Gos design och dess approach till abstraktion och polymorfism — och deras **implicita uppfyllelse** (ingen `implements`-nyckelord; strukturell typning) är en av de mest distinkta och kraftfulla funktionerna i språket.

Denna frikoppling innebär att typer och interfaces kan utvecklas oberoende, du kan definiera interfaces *efter* de typer som uppfyller dem, och alla överensstämmande typer kopplas automatiskt in i interface-baserad kod — vilket möjliggör flexibel, löst kopplad design och enkel testning (byt in mock-implementeringar).

Att förstå implicit implementering, polymorfism via interfaces, det tomma interfacet/`any`, idiomen med små interfaces ("acceptera interfaces, returnera structs"), och de överallt förekommande standard-library-interfacen (`error`, `io.Reader`/`Writer`, `Stringer`) är väsentligt för idiomatisk Go.

Det är ett vanligt intervjuämne preciserade för att den implicita, strukturella modellen skiljer sig så fundamentalt från de explicita interfacen i Java/C#.

Definition och implicit implementering av ett interface

Polymorfism genom interfaces

Det tomma interfacet och any

Standard library-interfaces du använder konstant

Idiomen: acceptera interfaces, returnera structs

Varför det spelar roll

Det tomma interfacet och `any`