O que são módulos e mixins?

Question

Accepted Answer

**Módulos** são contêineres para métodos e constantes que não podem ser instanciados. Seu principal uso é como **mixins** — compartilhar métodos entre classes via `include` (já que Ruby tem herança simples). Módulos também fornecem **namespacing**. Mixins são a alternativa elegante do Ruby para herança múltipla. ## Módulos como mixins — compartilhando comportamento entre classes ```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 ``` Com **herança simples** do Ruby, módulos resolvem a reutilização de código entre classes não relacionadas: um módulo define métodos, e qualquer classe pode `include`-lo para ganhar esses métodos. Uma classe pode incluir **muitos** módulos — a resposta do Ruby para herança múltipla. ## 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`** adiciona os métodos do módulo como métodos de instância; **`extend`** os adiciona como métodos de classe. ## 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 ``` Módulos também servem como **namespaces**, agrupando classes/constantes relacionadas sob um nome (`Payments::Processor`) para evitar colisões. ## Mixins do 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 ``` Os mixins built-in do Ruby (**`Comparable`**, **`Enumerable`**) são poderosos: implemente um método (`<=>` ou `each`) e o módulo fornece muitos mais (comparações, ou `map`/`select`/etc.). ## Por que isso importa Módulos e mixins são características importantes e distintivas do Ruby, centrais para como Ruby consegue reutilização e organização de código, então compreendê-los é essencial para Ruby idiomático. Com **herança simples** do Ruby, **mixins** (incluir módulos em classes via `include`) são a solução elegante do Ruby para compartilhar comportamento entre classes não relacionadas — uma classe pode incluir múltiplos módulos para ganhar seus métodos, fornecendo os benefícios de herança múltipla sem seus problemas. Isso é fundamental para como código Ruby (e Rails) é estruturado: comportamento transversal é empacotado em módulos e misturado em classes que precisam dele. Compreender `include` (métodos de instância) vs `extend` (métodos de classe), módulos como **namespaces** (agrupando código relacionado para evitar colisões), e especialmente os poderosos mixins built-in do Ruby (**`Comparable`** e **`Enumerable`** — onde implementar um método como `<=>` ou `each` lhe dá muitos métodos de graça) é importante tanto para escrever Ruby reutilizável quanto para entender o código do framework que você usa. Módulos/mixins são como Ruby compõe comportamento elegantemente, e aparecem em toda a biblioteca padrão e frameworks. Dominar eles — mixins para compartilhamento de código (alternativa de herança múltipla do Ruby), include vs extend, namespacing, e alavancando Comparable/Enumerable — é conhecimento importante e frequentemente aplicado que reflete compreensão do design composicional do Ruby e é essencial para escrever Ruby idiomático e reutilizável, sendo um tópico comum de entrevista.