Un mémorandum du modèle (d'association) de Rails Référence: Rails Guide https://railsguides.jp/association_basics.html
La connexion entre deux modèles Active Record s'appelle une association. Dans ce qui suit, les associations seront décrites de manière unifiée avec les associations. La raison de l'association ・ Permet des opérations communes entre les modèles, rendant l'écriture de code simple et facile ・ Ce qui précède améliorera la visibilité du code. Parce que.
Example Prenant comme exemple une application de gestion de tâches simple, nous écrirons l'association entre l'utilisateur (User) et la tâche (Task). (Écrivez le long du guide des rails)
class User < ApplicationRecord
end
class Task < ApplicationRecord
end
Si l'utilisateur décrit le cas de l'ajout d'une nouvelle tâche et le cas de la suppression de l'utilisateur sans association, la mise en œuvre sera la suivante.
#Ajouter une nouvelle tâche
@task = Task.create(task: "achats", user_id: @user.id)
#Supprimer l'utilisateur(Dans ce cas, si vous ne supprimez pas toutes les tâches de l'utilisateur à supprimer ensemble, des données sans signification resteront à jamais dans la base de données.)
@tasks = Task.where(user_id: @user.id)
@tasks.each do |task|
task.destroy
end
@user.destroy
En ajoutant explicitement des associations au modèle Rails, vous pouvez écrire votre code de manière plus concise. Tout d'abord, définissez l'association de modèle.
class User < ApplicationRecord
#L'utilisateur a plusieurs tâches,Défini que lorsqu'un utilisateur est supprimé, supprimez également toutes les tâches
has_many :tasks, dependent: :destroy
end
class Task < ApplicationRecord
#Les tâches sont créées par un utilisateur
belong_to :user
end
Ceci complète l'association. Si vous expliquez has_many et appartiennent_to assez grossièrement
Du point de vue de l'utilisateur, il peut avoir plusieurs tâches telles que Task_a, Task_b, Task_c, Vu de la tâche, il n'y a qu'un seul utilisateur Je l'ai défini dans Rails comme une relation un (utilisateur) à plusieurs (tâche).
À propos, l'option dépendante :: destroy est Lorsqu'un utilisateur est supprimé, cela signifie que toutes les tâches de cet utilisateur doivent être supprimées.
En faisant l'association comme ci-dessus, L'ajout de nouvelles tâches et la suppression d'utilisateurs peuvent maintenant être décrits brièvement comme suit.
#Ajouter une nouvelle tâche
@task = @user.tasks.create(task: "achats")
#Supprimer l'utilisateur(dependent: :L'option destroy supprime également la tâche de l'utilisateur.)
@user.destroy
En particulier, la partie supprimée ne nécessite qu'une seule ligne pour cinq lignes. En regardant le code, je pouvais immédiatement comprendre ce que je faisais et les perspectives se sont améliorées.
belongs_to has_one has_many has_many :through has_one :through has_and_belongs_to_many
La description
belong_to Une association un-à-un est définie. Toutes les instances du modèle déclarant "appartiennent" à l'instance de l'autre modèle. Prenant l'exemple de chapitre comme exemple, il exprime la relation d'affectation d'un utilisateur à une tâche. Le nom de modèle spécifié dans l'association appartient_to doit toujours être "single form".
#Puisqu'il n'y a qu'un seul utilisateur, il doit être singulier.
#L'estimation automatique des rails entraîne une erreur.
class Task < ApplicationRecord
belong_to :user
end
has_one Une association un-à-un est définie. La différence avec appartenir est Indique que l'instance de modèle déclarée "contient" ou "possède" une instance de l'autre modèle. Prenons l'exemple du certificat national d'assurance maladie (difficile à comprendre (rires)?)
Une personne possède une police d'assurance.
class people < ApplicationRecord
has_one :insurance_card
end
Une personne a une police d'assurance.
class insurance_card < ApplicationRecord
belong_to :people
end
has_many Indique qu'il existe une connexion «un-à-plusieurs». Si l'association has_many est utilisée, une instance de ce modèle possède "zéro ou plusieurs" instances du modèle opposé. En prenant l'exemple de chapitre comme exemple, il est possible d'exprimer une relation dans laquelle un utilisateur a plusieurs tâches. Lors de la déclaration d'une association has_many, le nom de modèle de l'autre partie doit être "pluriel".
#Étant donné que plusieurs tâches peuvent appartenir à un seul utilisateur, elles doivent être décrites au pluriel.
#L'estimation automatique des rails entraîne une erreur.
class User < ApplicationRecord
has_many :tasks
end
has_many :through Souvent utilisé pour configurer des connexions «plusieurs à plusieurs». Cette association crée un «troisième modèle (modèle intermédiaire)» entre les deux modèles. En conséquence, il correspond à "0 ou plus" instances du modèle adverse. Il est possible de limiter les étudiants qui fréquentent une classe spécifique à partir de plusieurs classes et de plusieurs étudiants.
Les étudiants prennent plusieurs leçons.
class Student < ApplicationRecord
has_many :members
has_many :class_works, through: :members
end
En enregistrant les identifiants de plusieurs classes et de plusieurs étudiants, il est possible de limiter les étudiants qui sont dans une classe spécifique.
class Member < ApplicationRecord
belongs_to :student
belongs_to :class_work
end
Le cours est suivi par plusieurs étudiants.
class Class_work < ApplicationRecord
has_many :members
has_many :students, through: :members
end
has_one :through Définissez une connexion «un à un». Cette association crée un «troisième modèle (modèle intermédiaire)» entre les deux modèles. Il correspond à une instance de l'autre modèle. Je ne peux pas y penser, alors je vais prendre le guide Rails comme exemple.
Si un fournisseur est associé à un compte et qu'un compte est associé à un historique de compte, le modèle du fournisseur ressemble à ceci:
#Le fournisseur a un compte et un compte via le compte_Avoir une histoire.
class Supplier < ApplicationRecord
has_one :account
has_one :account_history, through: :account
end
#le compte appartient au fournisseur et au compte_Avoir une histoire
class Account < ApplicationRecord
belongs_to :supplier
has_one :account_history
end
#L'historique du compte appartient au compte
class AccountHistory < ApplicationRecord
belongs_to :account
end
has_and_belongs_to_many Créez une connexion "plusieurs à plusieurs". Cependant, contrairement au cas où through: est spécifié, il n'y a pas de troisième modèle (modèle intermédiaire). S'il y a un assemblage et une pièce, et qu'une voiture finie correspond à plusieurs pièces, et inversement, une pièce correspond également à plusieurs voitures finies, la déclaration du modèle est la suivante. Sera.
#La voiture finie comporte de nombreuses pièces(parts)Est attaché et devient une voiture.
class Assembly < ApplicationRecord
has_and_belongs_to_many :parts
end
#Il existe plusieurs pièces, qui sont attachées à plusieurs véhicules finis.
class Part < ApplicationRecord
has_and_belongs_to_many :assemblies
end
Recommended Posts