Go Academy · Lezione

Struct anonime e composizione

Embedding e riutilizzo del codice basato sulle struct

Lezione 4 di 413 passaggi

Struct anonime e composizione è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

Struct anonime

Una struct anonima non ha un tipo denominato. Viene definita inline ed è utile per dati di breve durata, test basati su tabelle e raggruppamenti occasionali:

package main
import "fmt"

func main() {
    point := struct{ X, Y int }{X: 3, Y: 7}
    fmt.Println(point.X, point.Y)
}

Struct anonime nei test basati su tabelle

Un idioma comune di Go utilizza una slice di struct anonime per i test basati su tabelle:

package main
import "fmt"

func double(n int) int { return n * 2 }

func main() {
    tests := []struct{ input, want int }{
        {1, 2}, {5, 10}, {0, 0},
    }
    for _, tt := range tests {
        got := double(tt.input)
        if got != tt.want {
            fmt.Printf("FAIL: double(%d) = %d, want %d\n", tt.input, got, tt.want)
        }
    }
    fmt.Println("all tests passed")
}

Embedding di struct

L'embedding di un tipo all'interno di una struct promuove i suoi campi e metodi nella struct esterna:

package main
import "fmt"

type Animal struct{ Name string }
func (a Animal) Speak() string { return a.Name + " speaks" }

type Dog struct {
    Animal        // embedded
    Breed string
}

func main() {
    d := Dog{Animal: Animal{"Rex"}, Breed: "Labrador"}
    fmt.Println(d.Name)    // promoted field
    fmt.Println(d.Speak()) // promoted method
}

Embedding multiplo

Una struct può includere più tipi tramite embedding. I conflitti (stesso nome di campo o metodo) devono essere risolti esplicitamente:

package main
import "fmt"

type Logger struct{}
func (Logger) Log(s string) { fmt.Println("[LOG]", s) }

type Metrics struct{}
func (Metrics) Count() int { return 42 }

type Service struct {
    Logger
    Metrics
    Name string
}

func main() {
    svc := Service{Name: "auth"}
    svc.Log("started")       // from Logger
    fmt.Println(svc.Count()) // from Metrics
}

Embedding ed ereditarietà

Go non ha l'ereditarietà tra classi. L'embedding è composizione:

L'embedding promuove campi e metodi, ma il tipo esterno non è un sottotipo
Non è possibile passare un Dog quando è previsto un Animal
Utilizzi le interfacce per il polimorfismo e l'embedding per riutilizzare il codice

Sovrascrivere i metodi promossi

La struct esterna può nascondere un metodo embedded definendone uno proprio:

package main
import "fmt"

type Base struct{}
func (Base) Hello() string { return "Base hello" }

type Child struct{ Base }
func (Child) Hello() string { return "Child hello" } // shadows Base.Hello

func main() {
    c := Child{}
    fmt.Println(c.Hello())      // Child hello
    fmt.Println(c.Base.Hello()) // Base hello (explicit)
}

Struct anonima per la configurazione

Utilizzi una struct anonima per raggruppare configurazioni correlate senza definire un tipo denominato:

package main
import "fmt"

func main() {
    cfg := struct {
        Host string
        Port int
        TLS  bool
    }{
        Host: "api.example.com",
        Port: 443,
        TLS:  true,
    }
    fmt.Println(cfg)
}

Embedding di un'interfaccia

L'embedding di un'interfaccia in una struct è utile per il mocking e le implementazioni predefinite:

package main
import "fmt"

type Reader interface{ Read() string }

type Mock struct{ Reader }  // embed interface

func main() {
    m := Mock{}
    fmt.Printf("%T\n", m.Reader) // <nil> — not set
    // Assign a real impl at test time:
    _ = m
}

Problemi della composizione tramite struct

Presti attenzione a:

Selettori ambigui quando due tipi embedded hanno lo stesso nome di campo o metodo
Un puntatore embedded nil che causa un panic quando se ne chiamano i metodi
Dimenticare che l'embedding non è ereditarietà: non è possibile sostituire il tipo embedded con quello esterno

Confrontare struct anonime

Due struct anonime con gli stessi nomi e tipi di campo sono assegnabili l'una all'altra se anche i relativi tag corrispondono:

package main
import "fmt"

func main() {
    a := struct{ X, Y int }{1, 2}
    b := struct{ X, Y int }{1, 2}
    fmt.Println(a == b) // true
}

Verifica rapida

Qual è il risultato dell'embedding di un tipo in una struct?

Rispondi nella lezione interattiva

Riepilogo: composizione

Punti chiave:

Le struct anonime sono ideali per i test basati su tabelle e per i dati di breve durata
L'embedding promuove campi e metodi: è composizione, non ereditarietà
I tipi esterni possono nascondere i metodi embedded
Risolva esplicitamente i selettori ambigui
Utilizzi le interfacce per il polimorfismo

Traccia per l'esercizio

Crei una struct TimestampedRecord che includa tramite embedding una Timestamp struct{ CreatedAt, UpdatedAt string } e una Data struct{ Key, Value string }. La istanzi e stampi tutti i campi promossi.

Gratis per iniziare

Impara Go con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 51
Lezioni: 203

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Struct anonime e composizione» è gratuita?

Sì — il testo completo di «Struct anonime e composizione» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «Struct anonime e composizione»?

Embedding e riutilizzo del codice basato sulle struct Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Struct anonime e composizione»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Go Academy