Ruby Academy · Lezione

Associazioni

has_many e belongs_to

Associazioni è una lezione Ruby 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 Ruby Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Ruby Academy include 4 lezioni in totale.

Che cosa sono le associazioni?

Le associazioni dichiarano le relazioni tra i modelli, così Active Record può navigare automaticamente tra le righe correlate. Invece di scrivere SQL con join, può chiamare metodi come user.posts.

Rispecchiano le chiavi esterne del database.
Generano automaticamente metodi di supporto.
Rendono il codice simile al dominio applicativo.

belongs_to

belongs_to indica che questo modello contiene una chiave esterna che punta a un altro modello. Un Comment che appartiene a un Post ha una colonna post_id.

class Comment < ApplicationRecord
  belongs_to :post
end

# comment.post returns the parent Post
# Requires a post_id column on comments

has_many

has_many rappresenta l'altro lato: un record possiede molti record di un altro modello. Un Post ha molti record Comment. La chiave esterna si trova sul lato dei molti.

class Post < ApplicationRecord
  has_many :comments
end

# post.comments returns all related comments
# post.comments.create(body: "Nice!")

Dove si trova la chiave esterna

Il modello che utilizza belongs_to contiene la chiave esterna. Per Post e Comment, la tabella comments contiene post_id. Configuri questa relazione in una migrazione con t.references :post o add_reference.

create_table :comments do |t|
  t.references :post, foreign_key: true
  t.text :body
  t.timestamps
end

Metodi generati

Un'associazione has_many :comments fornisce una raccolta con comodi metodi:

post.comments per leggere.
post.comments.create(...) per aggiungere un record collegato.
post.comments.count per contare.
post.comment_ids per ottenere gli ID.

post = Post.find(1)
post.comments.create(body: "First!")
puts post.comments.count

has_one

has_one rappresenta un collegamento uno a uno, come un User che ha un solo Profile. La chiave esterna si trova comunque sull'altro modello (profiles.user_id).

class User < ApplicationRecord
  has_one :profile
end

class Profile < ApplicationRecord
  belongs_to :user
end

Molti a molti con through

Per una relazione molti a molti, utilizzi un modello di collegamento e has_many through. Uno Student ha molti record Course attraverso le righe Enrollment.

class Student < ApplicationRecord
  has_many :enrollments
  has_many :courses, through: :enrollments
end

class Enrollment < ApplicationRecord
  belongs_to :student
  belongs_to :course
end

Opzioni dependent

Stabilisca cosa accade ai record dipendenti quando viene eliminato il record principale con dependent:

dependent: :destroy elimina anche i record dipendenti.
dependent: :nullify cancella la loro chiave esterna.
dependent: :restrict_with_error impedisce l'eliminazione.

class Post < ApplicationRecord
  has_many :comments, dependent: :destroy
end

Il problema delle query N+1

Scorrere i record e accedere a un'associazione può eseguire una query per ogni record: il temuto problema N+1. Caricare 10 post e i relativi commenti può richiedere 11 query invece di 2.

Questo rallenta le applicazioni in modo silenzioso man mano che i dati aumentano.

# N+1: one query per post for comments
Post.all.each do |post|
  puts post.comments.count
end

Correggere N+1 con includes

includes indica ad Active Record di precaricare l'associazione con poche query invece di eseguirne molte. È la soluzione standard al problema N+1.

Post.includes(:comments).each do |post|
  puts post.comments.count
end

Nomi personalizzati con class_name

Quando il nome dell'associazione non corrisponde al modello, utilizzi opzioni come class_name e foreign_key. Ad esempio, un'associazione author supportata dal modello User.

class Post < ApplicationRecord
  belongs_to :author, class_name: "User"
end

Verifica rapida

Verifichi la propria comprensione delle associazioni.

Riepilogo: associazioni

Ha imparato a mettere in relazione i modelli:

belongs_to contiene la chiave esterna; has_many e has_one rappresentano l'altro lato.
has_many through rappresenta le relazioni molti a molti.
dependent controlla le eliminazioni a cascata.
Eviti le query N+1 con includes.

Ora garantirà l'integrità dei dati con le validazioni e imparerà a eseguire query.

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 Ruby Academy, passa a CoddyKit PRO. Il corso Ruby Academy include 4 lezioni in totale.

Cosa imparerò in «Associazioni»?

has_many e belongs_to Eserciti Ruby 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 Ruby Academy?

Non è richiesta alcuna esperienza precedente. Ruby 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 Ruby Academy?

Sì. Ogni lezione Ruby 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 Ruby Academy