Come funzionano le interfacce in Go?

Question

Accepted Answer

Un'**interfaccia** Go definisce un insieme di firme di metodi — un contratto di comportamento. In modo cruciale, le interfacce vengono soddisfatte **implicitamente**: qualsiasi tipo che abbia quei metodi soddisfa automaticamente l'interfaccia, **senza nessuna dichiarazione esplicita "implements"**. Questo approccio strutturale, basato su duck-typing, è distintivo e potente.

## Definizione e implementazione implicita di un'interfaccia

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

Non esiste la parola chiave `implements` — se un tipo ha tutti i metodi dell'interfaccia, la soddisfa automaticamente. Questo disaccoppia l'interfaccia dalle sue implementazioni (l'implementatore non ha nemmeno bisogno di sapere che l'interfaccia esiste).

## Polimorfismo attraverso le interfacce

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

Le interfacce consentono il polimorfismo — scrivi il codice rispetto al comportamento, e qualsiasi tipo conforme funziona.

## L'interfaccia vuota e `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
```

L'interfaccia vuota (`interface{}` / `any`) contiene qualsiasi valore — usata quando il tipo non è noto in anticipo (anche se i generici ora spesso sostituiscono questa).

## Interfacce della standard library che userai costantemente

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

Molta della standard library è costruita su interfacce piccole (`io.Reader`/`io.Writer`, `error`, `Stringer`) — implementarle rende i tuoi tipi compatibili con tutto l'ecosistema.

## L'idioma: accetta interfacce, restituisci struct

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

## Perché è importante

Le interfacce sono centrali nel design di Go e nel suo approccio all'astrazione e al polimorfismo — e la loro **soddisfazione implicita** (nessuna parola chiave `implements`; tipizzazione strutturale) è una delle caratteristiche più distintive e potenti del linguaggio.

Questo disaccoppiamento significa che tipi e interfacce evolvono indipendentemente, puoi definire interfacce *dopo* i tipi che le soddisfano, e qualsiasi tipo conforme si integra automaticamente nel codice basato su interfacce — consentendo design flessibili e debolmente accoppiati e test facili (sostituisci implementazioni mock).

Comprendere l'implementazione implicita, il polimorfismo via interfacce, l'interfaccia vuota/`any`, l'idioma delle interfacce piccole ("accetta interfacce, restituisci struct"), e le ubique interfacce della standard library (`error`, `io.Reader`/`Writer`, `Stringer`) è essenziale per un Go idiomatico.

È un argomento frequente nei colloqui esattamente perché il modello implicito e strutturale differisce così fondamentalmente dalle interfacce esplicite di Java/C#.

Definizione e implementazione implicita di un'interfaccia

Polimorfismo attraverso le interfacce

L'interfaccia vuota e any

Interfacce della standard library che userai costantemente

L'idioma: accetta interfacce, restituisci struct

Perché è importante

L'interfaccia vuota e `any`