Go Academy · Lezione

Associazioni

Modellare le relazioni

Associazioni è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 3 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.

Modellazione delle relazioni

Le associazioni di GORM mappano le relazioni tra tabelle nei campi delle struct. I quattro tipi sono has one, has many, belongs to e many to many.

Esprima le chiavi esterne come campi delle struct
Carichi automaticamente i dati correlati
Crei insieme i record correlati

Has Many

Un utente ha molti post. Il parent contiene uno slice di child e il child contiene una chiave esterna che rimanda al parent.

type User struct {
    gorm.Model
    Name  string
    Posts []Post
}

type Post struct {
    gorm.Model
    Title  string
    UserID uint
}

Belongs To

Dal punto di vista del child, un post appartiene a un utente. Aggiunga un campo User e la chiave esterna UserID per esprimere questa relazione.

type Post struct {
    gorm.Model
    Title  string
    UserID uint
    User   User
}

Has One

Una relazione has-one è simile a has-many, ma prevede un solo record correlato, per esempio un utente con un unico profilo. Il child contiene la chiave esterna.

type User struct {
    gorm.Model
    Profile Profile
}

type Profile struct {
    gorm.Model
    UserID uint
    Bio    string
}

Many To Many

Utenti e ruoli hanno una relazione many-to-many tramite una tabella di join. Il tag many2many specifica il nome di tale tabella, scritto come gorm:"many2many:user_roles;" tra backtick dopo il campo Roles.

type User struct {
    gorm.Model
    // Roles field tag: gorm:"many2many:user_roles;"
    Roles []Role
}

type Role struct {
    gorm.Model
    Name string
}

Preload

Per impostazione predefinita, i dati correlati non vengono caricati. Preload indica a GORM di recuperare le associazioni con una query separata, evitando una ricerca manuale distinta.

var user User
db.Preload("Posts").First(&user, 1)
fmt.Println(len(user.Posts))

Preload annidato

Può eseguire il preload su più livelli usando un percorso separato da punti, caricando in una sola catena di chiamate i post degli utenti e i commenti di ciascun post.

db.Preload("Posts.Comments").First(&user, 1)

Una simulazione eseguibile delle associazioni

GORM richiede un database, quindi questo esempio eseguibile modella una relazione has-many e il preloading usando slice in memoria.

package main

import "fmt"

type Post struct {
    ID     int
    UserID int
    Title  string
}

type User struct {
    ID    int
    Name  string
    Posts []Post
}

func preload(u *User, all []Post) {
    for _, p := range all {
        if p.UserID == u.ID {
            u.Posts = append(u.Posts, p)
        }
    }
}

func main() {
    u := User{ID: 1, Name: "Ada"}
    all := []Post{{1, 1, "Hello"}, {2, 1, "World"}, {3, 2, "Other"}}
    preload(&u, all)
    fmt.Printf("%s has %d posts\n", u.Name, len(u.Posts))
}

Creazione con le associazioni

Se imposta il campo slice prima di Create, GORM inserisce insieme il parent e i suoi child e collega automaticamente le chiavi esterne.

user := User{Name: "Ada", Posts: []Post{{Title: "Hi"}}}
db.Create(&user)

Il problema N+1

Scorrere i parent ed eseguire una query sui child a ogni iterazione causa una query per ogni parent: il problema N+1. Preload lo risolve raggruppando il recupero dei dati correlati in un'unica query aggiuntiva.

Modalità Association

L'API Association aggiunge, sostituisce, elimina o rimuove le associazioni senza dover gestire manualmente le chiavi esterne, per esempio db.Model(&user).Association("Posts").Append(&post).

Verifica rapida

Verifichi le Sue conoscenze sulle associazioni.

Riepilogo

Ha imparato a usare le associazioni:

Le relazioni has one, has many, belongs to e many2many tra i model
Le chiavi esterne sono campi delle struct come UserID
Preload carica le associazioni ed evita il problema N+1
La creazione di un parent con i child collega le chiavi esterne
La modalità Association aggiunge, sostituisce o rimuove le relazioni

Domande Frequenti

La lezione «Associazioni» è gratuita?

Sì — il testo completo di «Associazioni» è 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 «Associazioni»?

Modellare le relazioni 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 3 di 4.

Quanto tempo richiede la lezione «Associazioni»?

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