Ruby Academy · Lección

Asociaciones

has_many y belongs_to

Asociaciones es una lección gratuita de Ruby Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Ruby Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Ruby Academy incluye 4 lecciones en total.

¿Qué son las asociaciones?

Las asociaciones declaran relaciones entre modelos para que Active Record pueda navegar por los registros relacionados. En lugar de escribir SQL de unión, puede llamar a métodos como user.posts.

Reflejan las claves foráneas de la base de datos.
Generan métodos auxiliares automáticamente.
Hacen que el código se lea como el dominio del problema.

belongs_to

belongs_to indica que este modelo contiene una clave foránea que apunta a otro. Un Comment que pertenece a un Post tiene una columna 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 es el otro lado: un registro tiene muchos registros de otro modelo. Un Post tiene muchos registros Comment. La clave foránea reside en el lado «muchos».

class Post < ApplicationRecord
  has_many :comments
end

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

Dónde reside la clave foránea

El modelo que tiene belongs_to contiene la clave foránea. En el caso de Post y Comment, la tabla comments tiene post_id. Configure esto en una migración con t.references :post o add_reference.

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

Métodos generados

Un has_many :comments le proporciona una colección con métodos útiles:

post.comments para leer.
post.comments.create(...) para añadir un registro vinculado.
post.comments.count para contar.
post.comment_ids para obtener los identificadores.

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

has_one

has_one modela una relación uno a uno, como un User que tiene un Profile. La clave foránea sigue estando en el otro modelo (profiles.user_id).

class User < ApplicationRecord
  has_one :profile
end

class Profile < ApplicationRecord
  belongs_to :user
end

Muchos a muchos con through

Para las relaciones de muchos a muchos, use un modelo de unión y has_many through. Un Student tiene muchos registros Course a través de las filas de Enrollment.

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

class Enrollment < ApplicationRecord
  belongs_to :student
  belongs_to :course
end

Opciones de dependent

Decida qué ocurre con los registros secundarios cuando se elimina un registro principal mediante dependent:

dependent: :destroy elimina también los registros secundarios.
dependent: :nullify borra sus claves foráneas.
dependent: :restrict_with_error impide la eliminación.

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

El problema de las consultas N+1

Recorrer registros y acceder a una asociación puede ejecutar una consulta por registro: el temido N+1. Cargar 10 posts y después sus comentarios puede ejecutar 11 consultas en lugar de 2.

Esto ralentiza silenciosamente las aplicaciones a medida que aumentan los datos.

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

Corregir N+1 con includes

includes indica a Active Record que cargue la asociación de forma anticipada en un par de consultas en lugar de hacerlo en muchas. Esta es la solución habitual para N+1.

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

Nombres personalizados con class_name

Cuando el nombre de la asociación no coincide con el modelo, use opciones como class_name y foreign_key. Por ejemplo, una asociación author respaldada por el modelo User.

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

Comprobación rápida

Compruebe cuánto ha entendido sobre las asociaciones.

Resumen: asociaciones

Ha aprendido a relacionar modelos:

belongs_to contiene la clave foránea; has_many y has_one representan el otro lado.
has_many through modela las relaciones de muchos a muchos.
dependent controla las eliminaciones en cascada.
Evite las consultas N+1 con includes.

A continuación, garantizará la integridad de los datos mediante validaciones y aprenderá a consultar.

Preguntas frecuentes

¿La lección «Asociaciones» es gratis?

Sí — el texto completo de «Asociaciones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Ruby Academy, actualiza a CoddyKit PRO. El curso de Ruby Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Asociaciones»?

has_many y belongs_to Practicas Ruby Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Ruby Academy?

No se requiere experiencia previa. Ruby Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Asociaciones»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Ruby Academy?

Sí. Cada lección de Ruby Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Ruby Academy