¿Qué son módulos y mixins?

Question

Accepted Answer

**Módulos** son contenedores para métodos y constantes que no pueden ser instanciados. Su principal uso es como **mixins** — compartir métodos entre clases mediante `include` (ya que Ruby tiene herencia simple). Los módulos también proporcionan **namespacing**. Los mixins son la alternativa elegante de Ruby a la herencia múltiple. ## Módulos como mixins — compartir comportamiento entre clases ```ruby 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 ``` Ya que Ruby tiene **herencia simple**, los módulos resuelven la reutilización de código entre clases no relacionadas: un módulo define métodos, y cualquier clase puede hacer `include` para obtener esos métodos. Una clase puede incluir **muchos** módulos — la respuesta de Ruby a la herencia múltiple. ## include vs extend ```ruby 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`** añade los métodos del módulo como métodos de instancia; **`extend`** los añade como métodos de clase. ## Módulos para namespacing ```ruby module Payments class Processor; end # fully qualified: Payments::Processor TAX_RATE = 0.08 end Payments::Processor.new # access via the namespace — avoids name collisions ``` Los módulos también sirven como **espacios de nombres**, agrupando clases/constantes relacionadas bajo un nombre (`Payments::Processor`) para evitar colisiones. ## Mixins del mundo real (Comparable, Enumerable) ```ruby 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 ``` Los mixins incorporados de Ruby (**`Comparable`**, **`Enumerable`**) son poderosos: implementa un método (`<=>` o `each`) y el módulo proporciona muchos más (comparaciones, o `map`/`select`/etc.). ## Por qué es importante Los módulos y mixins son características distintivas e importantes de Ruby, centrales en cómo Ruby logra la reutilización de código y organización, por lo que entenderlos es esencial para Ruby idiomático. Ya que Ruby tiene **herencia simple**, los **mixins** (incluir módulos en clases mediante `include`) son la solución elegante de Ruby para compartir comportamiento entre clases no relacionadas — una clase puede incluir múltiples módulos para obtener sus métodos, proporcionando los beneficios de herencia múltiple sin sus problemas. Esto es fundamental para cómo se estructura el código Ruby (y Rails): el comportamiento transversal se empaqueta en módulos y se mezcla en clases que lo necesitan. Entender `include` (métodos de instancia) vs `extend` (métodos de clase), módulos como **espacios de nombres** (agrupar código relacionado para evitar colisiones), y especialmente los poderosos mixins incorporados de Ruby (**`Comparable`** y **`Enumerable`** — donde implementar un método como `<=>` o `each` te da muchos métodos gratis) es importante tanto para escribir Ruby reutilizable como para entender el código del framework que usas. Los módulos/mixins son cómo Ruby compone comportamiento elegantemente, y aparecen por toda la biblioteca estándar y los frameworks. Dominarlos — mixins para compartir código (la alternativa de herencia múltiple de Ruby), include vs extend, namespacing, y aprovechar Comparable/Enumerable — es conocimiento importante y frecuentemente aplicado que refleja comprensión del diseño composicional de Ruby y es esencial para escribir Ruby idiomático y reutilizable, además de ser un tema común en entrevistas.