Ruby Academy · Aula

prepend e resolução de métodos

Cadeias de ancestrais.

prepend e resolução de métodos é uma aula grátis de Ruby Academy no CoddyKit. Esta é a aula 4 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.

Cadeias de ancestrais

Quando o senhor chama um método, Ruby pesquisa uma lista chamada cadeia de ancestrais. A primeira definição correspondente vence. Entender essa cadeia explica como as misturas e a herança interagem.

class Animal; end
class Dog < Animal; end
p Dog.ancestors

Ordem de busca de métodos

Ruby procura primeiro na classe do objeto, depois nos módulos incluídos, em seguida na superclasse e assim por diante pela cadeia, até encontrar o método.

module M
  def hello; "from module"; end
end
class C
  include M
  def hello; "from class"; end
end
puts C.new.hello

A inclusão fica abaixo da classe

Um módulo incluído com include fica logo abaixo da classe na cadeia. Os próprios métodos da classe têm prioridade sobre os do módulo.

module M; end
class C
  include M
end
p C.ancestors  # [C, M, Object, ...]

Conheça a inserção no início

prepend insere um módulo acima da classe na cadeia. Agora os métodos do módulo são encontrados primeiro, antes dos próprios métodos da classe.

module M
  def hello; "from module"; end
end
class C
  prepend M
  def hello; "from class"; end
end
puts C.new.hello

Inserção do módulo antes da classe

Inspecione os ancestrais para ver prepend colocar o módulo antes da classe.

module M; end
class C
  prepend M
end
p C.ancestors  # [M, C, Object, ...]

Método superior de um módulo inserido antes da classe

Como o módulo inserido antes da classe é executado primeiro, ele pode envolver o método da classe chamando super para alcançar o original. Isso é perfeito para decorar o comportamento.

module Logged
  def save
    puts "before save"
    result = super
    puts "after save"
    result
  end
end
class Record
  prepend Logged
  def save
    puts "saving record"
    :ok
  end
end
p Record.new.save

Método superior nas misturas

super segue a cadeia de ancestrais. Em um módulo incluído, super alcança a superclasse; em um módulo inserido antes da classe, ele alcança a própria classe.

module Polite
  def greet; "Hi! " + super; end
end
class Person
  prepend Polite
  def greet; "I am here."; end
end
puts Person.new.greet

Envolvimento sem edição

prepend permite adicionar comportamento ao redor de métodos existentes sem modificar o código da classe original, uma alternativa limpa à alteração direta de classes.

module Timing
  def compute(n)
    puts "start"
    super
  end
end
class Calc
  prepend Timing
  def compute(n); n * n; end
end
puts Calc.new.compute(5)

Ordem de vários módulos

Quando vários módulos são incluídos, o último incluído fica mais próximo da classe e é pesquisado primeiro.

module A; def who; "A"; end; end
module B; def who; "B"; end; end
class C
  include A
  include B
end
puts C.new.who  # B wins (included last)
p C.ancestors

Resumo: inclusão versus inserção no início

Lado a lado:

include M: a cadeia é [Class, M, ...] — os métodos da classe vencem.
prepend M: a cadeia é [M, Class, ...] — os métodos do módulo vencem e podem usar super para entrar na classe.

module M; end
class Inc; include M; end
class Pre; prepend M; end
p Inc.ancestors
p Pre.ancestors

Reunindo tudo

A resolução de métodos segue a cadeia de ancestrais:

Os métodos da classe vencem os módulos incluídos.
Os módulos inseridos antes da classe vencem a classe.
super percorre um passo para cima na cadeia.

module Cap
  def name; super.capitalize; end
end
class User
  prepend Cap
  def name; "ada"; end
end
puts User.new.name

Verificação rápida

Teste sua compreensão da resolução de métodos.

Recapitulação

O senhor aprendeu sobre a resolução de métodos:

Ruby pesquisa a cadeia de ancestrais de cima para baixo.
include fica abaixo da classe; prepend fica acima dela.
super alcança a próxima definição acima na cadeia.
prepend envolve métodos de forma limpa.

module Loud
  def speak; super.upcase; end
end
class Bot
  prepend Loud
  def speak; "beep"; end
end
puts Bot.new.speak

Perguntas Frequentes

A aula “prepend e resolução de métodos” é grátis?

Sim — o texto completo de “prepend e resolução de métodos” é 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 “prepend e resolução de métodos”?

Cadeias de ancestrais. 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 4 de 4.

Quanto tempo leva a aula “prepend e resolução de métodos”?

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