Ruby Academy · Aula

Associações

has_many e belongs_to.

Associações é uma aula grátis de Ruby Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Ruby Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Ruby Academy inclui 4 aulas no total.

O que são associações?

Associações declaram relações entre modelos para que Active Record possa navegar pelas linhas relacionadas. Em vez de escrever SQL de junção, você chama métodos como user.posts.

Elas refletem as chaves estrangeiras do banco de dados.
Geram métodos auxiliares automaticamente.
Fazem o código parecer escrito na linguagem do domínio.

belongs_to

belongs_to indica que este modelo contém uma chave estrangeira que aponta para outro. Um Comment que pertence a um Post tem uma coluna 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 é o outro lado: um registro possui muitos registros de outro tipo. Um Post possui muitos registros Comment. A chave estrangeira fica no lado que contém muitos registros.

class Post < ApplicationRecord
  has_many :comments
end

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

Onde fica a chave estrangeira

O modelo que usa belongs_to contém a chave estrangeira. No caso de Post e Comment, a tabela comments tem post_id. Configure isso em uma migração com t.references :post ou add_reference.

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

Métodos gerados

Uma associação has_many :comments oferece uma coleção com métodos úteis:

post.comments para leitura.
post.comments.create(...) para adicionar um registro vinculado.
post.comments.count para contar.
post.comment_ids para obter os identificadores.

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

has_one

has_one modela uma relação um para um, como um User que possui um Profile. A chave estrangeira ainda fica no outro modelo (profiles.user_id).

class User < ApplicationRecord
  has_one :profile
end

class Profile < ApplicationRecord
  belongs_to :user
end

Muitos para muitos com associação intermediária

Para relações muitos para muitos, use um modelo de junção e has_many through. Um Student possui muitos registros de curso por meio de linhas Enrollment.

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

class Enrollment < ApplicationRecord
  belongs_to :student
  belongs_to :course
end

Opções de dependência

Decida o que acontece com os registros dependentes quando um registro pai é excluído usando dependent:

dependent: :destroy exclui os registros dependentes também.
dependent: :nullify limpa a chave estrangeira deles.
dependent: :restrict_with_error bloqueia a exclusão.

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

O problema da consulta N+1

Percorrer registros e acessar uma associação pode disparar uma consulta por registro, o temido N+1. Carregar 10 publicações e seus comentários pode executar 11 consultas em vez de 2.

Isso desacelera silenciosamente as aplicações à medida que os dados crescem.

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

Corrigindo N+1 com includes

includes instrui Active Record a fazer o carregamento antecipado da associação em algumas consultas, em vez de fazer muitas. Essa é a correção padrão para N+1.

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

Nomes personalizados para associações

Quando o nome da associação não corresponde ao modelo, use opções como class_name e foreign_key. Por exemplo, uma associação author respaldada pelo modelo User.

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

Verificação rápida

Teste sua compreensão das associações.

Recapitulação: associações

Você aprendeu a relacionar modelos:

belongs_to contém a chave estrangeira; has_many e has_one são o outro lado.
has_many through modela relações muitos para muitos.
dependent controla as exclusões em cascata.
Evite consultas N+1 com includes.

Em seguida, garantiremos a integridade dos dados com validações e aprenderemos a fazer consultas.

Perguntas Frequentes

A aula “Associações” é grátis?

Sim — o texto completo de “Associações” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Ruby Academy, atualize para CoddyKit PRO. O curso de Ruby Academy inclui 4 aulas no total.

O que vou aprender em “Associações”?

has_many e belongs_to. Você pratica Ruby Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Ruby Academy?

Nenhuma experiência prévia é necessária. Ruby Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Associações”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Ruby Academy?

Sim. Cada aula de Ruby Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Ruby Academy