Ruby Academy · Leçon

Associations

has_many et belongs_to

Associations est une leçon Ruby Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Ruby Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Ruby Academy comprend 4 leçons au total.

Que sont les associations ?

Les associations déclarent les relations entre les modèles afin qu’Active Record puisse parcourir pour vous les lignes associées. Au lieu d’écrire des requêtes SQL de jointure, vous appelez des méthodes comme user.posts.

Elles reflètent les clés étrangères de votre base de données.
Elles génèrent automatiquement des méthodes utilitaires.
Elles rendent le code similaire au domaine métier.

belongs_to

belongs_to indique que ce modèle contient une clé étrangère pointant vers un autre modèle. Un Comment qui appartient à un Post possède une colonne 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 représente l’autre côté : un enregistrement possède plusieurs enregistrements d’un autre modèle. Un Post possède plusieurs enregistrements Comment. La clé étrangère se trouve du côté « plusieurs ».

class Post < ApplicationRecord
  has_many :comments
end

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

Où se trouve la clé étrangère

Le modèle qui utilise belongs_to contient la clé étrangère. Pour Post et Comment, la table comments possède post_id. Configurez cela dans une migration avec t.references :post ou add_reference.

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

Méthodes générées

Une association has_many :comments vous fournit une collection dotée de méthodes pratiques :

post.comments pour lire les enregistrements.
post.comments.create(...) pour ajouter un enregistrement associé.
post.comments.count pour compter les enregistrements.
post.comment_ids pour obtenir leurs identifiants.

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

has_one

has_one modélise une relation un-à-un, comme un User qui possède un Profile. La clé étrangère se trouve toujours dans l’autre modèle (profiles.user_id).

class User < ApplicationRecord
  has_one :profile
end

class Profile < ApplicationRecord
  belongs_to :user
end

Relation plusieurs-à-plusieurs avec through

Pour une relation plusieurs-à-plusieurs, utilisez un modèle de jointure et has_many through. Un Student possède plusieurs enregistrements Course par l’intermédiaire de lignes Enrollment.

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

class Enrollment < ApplicationRecord
  belongs_to :student
  belongs_to :course
end

Options de dépendance

Déterminez ce qui arrive aux enregistrements enfants lorsqu’un parent est supprimé avec dependent :

dependent: :destroy supprime également les enfants.
dependent: :nullify efface leur clé étrangère.
dependent: :restrict_with_error bloque la suppression.

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

Le problème des requêtes N+1

Parcourir des enregistrements et accéder à une association peut déclencher une requête par enregistrement : le fameux N+1. Charger 10 publications, puis leurs commentaires, peut entraîner 11 requêtes au lieu de 2.

Cela ralentit discrètement les applications à mesure que les données augmentent.

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

Corriger N+1 avec includes

includes indique à Active Record de charger l’association à l’avance en quelques requêtes plutôt qu’en de nombreuses requêtes. C’est la solution standard au problème N+1.

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

Noms personnalisés avec class_name

Lorsque le nom de l’association ne correspond pas au modèle, utilisez des options comme class_name et foreign_key. Par exemple, une association author peut s’appuyer sur le modèle User.

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

Vérification rapide

Vérifiez votre compréhension des associations.

Récapitulatif : associations

Vous avez appris à relier les modèles :

belongs_to contient la clé étrangère ; has_many et has_one représentent l’autre côté.
has_many through modélise les relations plusieurs-à-plusieurs.
dependent contrôle les suppressions en cascade.
Évitez les requêtes N+1 avec includes.

Vous allez maintenant garantir l’intégrité des données avec des validations et apprendre à effectuer des requêtes.

Questions Fréquemment Posées

La leçon « Associations » est-elle gratuite ?

Oui — le texte complet de « Associations » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Ruby Academy, passe à CoddyKit PRO. Le cours Ruby Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Associations » ?

has_many et belongs_to Tu pratiques Ruby Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Ruby Academy ?

Aucune expérience préalable n'est requise. Ruby Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Associations » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Ruby Academy ?

Oui. Chaque leçon Ruby Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Ruby Academy