Les modules sont des conteneurs pour les méthodes et les constantes qui ne peuvent pas être instanciées. Leur utilisation clé est comme mixins — partager des méthodes entre les classes via include (puisque Ruby a l'héritage simple). Les modules fournissent également la création d'espaces de noms. Les mixins sont l'alternative élégante de Ruby à l'héritage multiple.
module Greetable
def greet # methods defined in the module
"Hi, I'm #{name}"
end
end
module Trackable
def track(event)
puts "#{self.class}: #{event}"
end
end
class User
include Greetable # MIX IN the module's methods
include Trackable # include MULTIPLE modules
attr_reader :name
def initialize(name) = @name = name
end
User.new("Ann").greet # "Hi, I'm Ann" — method from the mixin
Puisque Ruby a l'héritage simple, les modules résolvent la réutilisation du code entre les classes non liées : un module définit des méthodes, et toute classe peut include pour obtenir ces méthodes. Une classe peut inclure plusieurs modules — la réponse de Ruby à l'héritage multiple.
module Helper
def help; "helping"; end
end
class A
include Helper # adds as INSTANCE methods → A.new.help
end
class B
extend Helper # adds as CLASS methods → B.help
end
include ajoute les méthodes du module en tant que méthodes d'instance ; extend les ajoute en tant que méthodes de classe.
module Payments
class Processor; end # fully qualified: Payments::Processor
TAX_RATE = 0.08
end
Payments::Processor.new # access via the namespace — avoids name collisions
Les modules servent aussi d'espaces de noms, regroupant les classes/constantes liées sous un nom (Payments::Processor) pour éviter les collisions.
class Temperature
include Comparable # mixing in Comparable gives <, >, ==, between?, etc.
attr_reader :degrees
def <=>(other) # just define <=> ...
degrees <=> other.degrees
end # ...and Comparable provides all comparison methods!
end
Les mixins intégrés de Ruby (Comparable, Enumerable) sont puissants : implémentez une méthode (<=> ou each) et le module en fournit beaucoup d'autres (comparaisons, ou map/select/etc.).
Les modules et les mixins sont des fonctionnalités Ruby importantes et distinctives, au cœur de la façon dont Ruby réalise la réutilisation du code et l'organisation, donc les comprendre est essentiel pour un Ruby idiomatique.
Puisque Ruby a l'héritage simple, les mixins (inclure des modules dans les classes via include) sont la solution élégante de Ruby pour partager le comportement entre les classes non liées — une classe peut inclure plusieurs modules pour obtenir leurs méthodes, fournissant les avantages de l'héritage multiple sans ses problèmes.
C'est fondamental pour la façon dont le code Ruby (et Rails) est structuré : le comportement transversal est emballé dans des modules et mixé dans les classes qui en ont besoin.
Comprendre include (méthodes d'instance) vs extend (méthodes de classe), les modules comme espaces de noms (regroupement du code connexe pour éviter les collisions), et surtout les puissants mixins intégrés de Ruby (Comparable et Enumerable — où implémenter une méthode comme <=> ou each vous donne de nombreuses méthodes gratuitement) est important pour à la fois écrire du Ruby réutilisable et comprendre le code du framework que vous utilisez.
Les modules/mixins sont la façon dont Ruby compose le comportement élégamment, et ils apparaissent partout dans la bibliothèque standard et les frameworks.
Les maîtriser — les mixins pour le partage du code (l'alternative d'héritage multiple de Ruby), include vs extend, la création d'espaces de noms, et l'utilisation de Comparable/Enumerable — est une connaissance importante et fréquemment appliquée qui reflète une compréhension de la conception compositionnelle de Ruby et est essentielle pour écrire un Ruby idiomatique et réutilisable et un sujet d'entretien courant.