Wat zijn modules en mixins?

Question

Accepted Answer

**Modules** zijn containers voor methoden en constanten die niet kunnen worden geïnstantieerd. Hun belangrijkste gebruik is als **mixins** — methoden delen tussen klassen via `include` (omdat Ruby single inheritance heeft). Modules bieden ook **namespacing**. Mixins zijn Ruby's elegante alternatief voor multiple inheritance. ## Modules als mixins — gedrag delen tussen klassen ```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 ``` Omdat Ruby **single inheritance** heeft, lossen modules code reuse op tussen niet-gerelateerde klassen: een module definieert methoden, en elke klasse kan het `include`n om die methoden te krijgen. Een klasse kan **veel** modules includeren — Ruby's antwoord op multiple inheritance. ## 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`** voegt de methoden van de module toe als instance methods; **`extend`** voegt ze toe als class methods. ## Modules voor 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 ``` Modules dienen ook als **namespaces**, waarbij gerelateerde klassen/constanten onder een naam worden gegroepeerd (`Payments::Processor`) om botsingen te voorkomen. ## Real-world mixins (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 ``` Ruby's ingebouwde mixins (**`Comparable`**, **`Enumerable`**) zijn krachtig: implementeer één methode (`<=>` of `each`) en de module biedt veel meer (comparisons, of `map`/`select`/etc.). ## Waarom het belangrijk is Modules en mixins zijn belangrijke, karakteristieke Ruby-features die centraal staan in hoe Ruby code reuse en organisatie bereikt, dus het begrijpen ervan is essentieel voor idiomatische Ruby. Omdat Ruby **single inheritance** heeft, zijn **mixins** (modules in klassen includeren via `include`) Ruby's elegante oplossing voor het delen van gedrag tussen niet-gerelateerde klassen — een klasse kan meerdere modules includeren om hun methoden te verkrijgen, wat de voordelen van multiple inheritance biedt zonder de problemen ervan. Dit is fundamenteel voor hoe Ruby code (en Rails) is gestructureerd: dwars-snijdend gedrag wordt verpakt in modules en gemengd in klassen die het nodig hebben. Het begrijpen van `include` (instance methods) vs `extend` (class methods), modules als **namespaces** (gerelateerde code groeperen om botsingen te vermijden), en vooral Ruby's krachtige ingebouwde mixins (**`Comparable`** en **`Enumerable`** — waar het implementeren van één methode zoals `<=>` of `each` je veel methoden gratis geeft) is belangrijk voor zowel het schrijven van herbruikbare Ruby als het begrijpen van de framework code die je gebruikt. Modules/mixins zijn hoe Ruby gedrag elegant samenvoegt, en ze verschijnen overal in de standaard library en frameworks. Het onder de knie krijgen van modules/mixins — mixins voor code sharing (Ruby's alternatief voor multiple inheritance), include vs extend, namespacing, en het benutten van Comparable/Enumerable — is belangrijk, regelmatig toegepaste kennis die begrip weerspiegelt van Ruby's compositional design en is essentieel voor het schrijven van idiomatische, herbruikbare Ruby en een veelgesteld interview-onderwerp.