Ruby Academy · Leçon

prepend et résolution des méthodes

Chaînes d’ancêtres

prepend et résolution des méthodes est une leçon Ruby Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Chaînes d'ancêtres

Lorsque vous appelez une méthode, Ruby parcourt une liste appelée chaîne d'ancêtres. La première définition correspondante est retenue. Comprendre cette chaîne explique comment les modules de mélange et l'héritage interagissent.

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

Ordre de recherche des méthodes

Ruby cherche d'abord dans la classe de l'objet, puis dans ses modules inclus, ensuite dans sa classe parente, et continue ainsi le long de la chaîne jusqu'à trouver la méthode.

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

include se place sous la classe

Un module inclus par include se place juste sous la classe dans la chaîne. Les propres méthodes de la classe sont prioritaires sur celles du module.

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

Découvrez la préinsertion

prepend insère un module au-dessus de la classe dans la chaîne. Les méthodes du module sont alors trouvées en premier, avant celles de la classe.

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

La préinsertion dans la chaîne

Examinez les ancêtres pour voir que prepend place le module avant la classe.

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

Atteindre la méthode d'origine depuis un module préinséré

Comme le module préinséré s'exécute en premier, il peut envelopper la méthode de la classe en appelant super pour atteindre l'originale. Cette technique est idéale pour décorer un comportement.

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

L'appel au parent dans les modules de mélange

super suit la chaîne d'ancêtres. Depuis un module inclus, super atteint la classe parente ; depuis un module préinséré, il atteint directement la classe.

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

Envelopper sans modifier

prepend vous permet d'ajouter un comportement autour de méthodes existantes sans modifier le code de la classe d'origine : c'est une alternative claire à la modification dynamique 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)

Ordre de plusieurs modules

Lorsque plusieurs modules sont inclus, le dernier module inclus est le plus proche de la classe et est recherché en premier.

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

Résumé : inclusion ou préinsertion

Comparaison :

include M : la chaîne est [Class, M, ...] — les méthodes de la classe sont prioritaires.
prepend M : la chaîne est [M, Class, ...] — les méthodes du module sont prioritaires et peuvent appeler super pour atteindre la classe.

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

Tout mettre en place

La résolution des méthodes suit la chaîne d'ancêtres :

Les méthodes de la classe sont prioritaires sur les modules inclus.
Les modules préinsérés sont prioritaires sur la classe.
super remonte d'un niveau dans la chaîne.

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

Vérification rapide

Évaluez votre compréhension de la résolution des méthodes.

Récapitulatif

Vous avez découvert la résolution des méthodes :

Ruby parcourt la chaîne d'ancêtres de haut en bas.
include se place sous la classe ; prepend se place au-dessus.
super atteint la définition suivante dans la chaîne.
prepend permet d'envelopper les méthodes proprement.

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

Questions Fréquemment Posées

La leçon « prepend et résolution des méthodes » est-elle gratuite ?

Oui — le texte complet de « prepend et résolution des méthodes » 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 « prepend et résolution des méthodes » ?

Chaînes d’ancêtres 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 4 sur 4.

Combien de temps prend la leçon « prepend et résolution des méthodes » ?

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