Mik azok a modulok és mixinek?

Question

Accepted Answer

**Modulok** olyan tárolók a metódusok és konstansok számára, amelyeket nem lehet példányosítani. Fő felhasználásuk a **mixinek** — metódusok megosztása osztályok között a `include` segítségével (mivel a Ruby egyszeres öröklödést támogat). A modulok **névteret** is biztosítanak. A mixinek a Ruby elegáns alternatívája a többszörös öröklödéshez. ## Modulok mint mixinek — viselkedés megosztása osztályok között ```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 ``` Azonos a **Ruby egyszeres öröklödése** miatt, a modulok megoldják a kódismétlödést a nem kapcsolódó osztályok között: egy modul metódusokat definiál, és bármely osztály `include`-olhatja azt, hogy megszerezze azokat a metódusokat. Egy osztály **több** modult is belefoglalhat — ez a Ruby válasza a többszörös öröklödésre. ## 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 ``` Az **`include`** a modul metódusait példánymetódusokként adja hozzá; az **`extend`** osztálymetódusokként. ## Modulok névtérként ```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 ``` A modulok **névtérként** is szolgálnak, rokon osztályok/konstansok csoportosításával egy név alatt (`Payments::Processor`), hogy elkerüljék az ütközéseket. ## Valós szintű mixinek (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 ``` A Ruby beépített mixinei (**`Comparable`**, **`Enumerable`**) erőteljesek: implementálj egy metódust (`<=>` vagy `each`) és a modul sokkal többet biztosít (összehasonlítások, vagy `map`/`select`/stb.). ## Miért is fontos A modulok és mixinek fontos, jellegzetes Ruby-funkciók, amelyek központiak abban, hogy a Ruby hogyan éri el a kódismétlödést és szervezést, ezért az ismeretük elengedhetetlen az idiomatikus Ruby-hoz. Mivel a Ruby **egyszeres öröklödésű**, a **mixinek** (modulok osztályokba való `include`-olása) a Ruby elegáns megoldása a viselkedés megosztására nem kapcsolódó osztályok között — egy osztály több modult is belefoglalhat, hogy megszerezze azok metódusait, így a többszörös öröklödés előnyeit anélkül, hogy annak problémái lennének. Ez alapvető abban, hogyan van strukturálva a Ruby-kód (és a Rails): az átfogó viselkedés modulokba van csomagolva és bekerül az azt igénylő osztályokba. Az `include` (példánymetódusok) vs `extend` (osztálymetódusok) megértése, modulok **névtérként** (kapcsolódó kód csoportosítása az ütközések elkerüléséhez), és különösen a Ruby erőteljes beépített mixinei (**`Comparable`** és **`Enumerable`** — ahol egy metódus, például `<=>` vagy `each` implementálása rengeteg metódust ad ingyenesen) fontos mind az újrafelhasználható Ruby írásához, mind az általad használt keretrendszer-kód megértéséhez. A modulok/mixinek az, ahogyan a Ruby elegánsan összeállítja a viselkedést, és megjelennek az összes standard könyvtárban és keretrendszerben. Azok elleni összevetés — mixinek a kódmegosztáshoz (a Ruby többszörös-öröklödés alternatívája), include vs extend, névtérkezelés, és Comparable/Enumerable kihasználása — fontos, gyakran alkalmazott tudás, amely tükrözi a Ruby összetétel-alapú dizájnjának megértését és elengedhetetlen az idiomatikus, újrafelhasználható Ruby írásához, valamint egy gyakori interjúkérdés.