మాడ్యూళ్లు మరియు మిక్సిన్‌లు అంటే ఏమిటి?

Question

Accepted Answer

**మాడ్యూళ్లు** అనేవి పద్ధతులు మరియు స్థిరాంకాలకు కంటైనర్‌లు, వీటిని ఇన్‌స్టాంటియేట్ చేయలేము. వాటి ప్రధాన ఉపయోగం **మిక్సిన్‌ల** వలె — `include` ద్వారా క్లాసుల్లో పద్ధతులను భాగస్వామ్యం చేయడం (Ruby కు ఒకే వారసత్వం ఉన్నందున). మాడ్యూళ్లు **నేమ్‌స్పేసింగ్** కూడా అందిస్తాయి. మిక్సిన్‌లు బహుళ వారసత్వానికి Ruby యొక్క సొగసైన ప్రత్యామ్నాయం. ## క్లాసుల్లో ప్రవర్తనను భాగస్వామ్యం చేయడం కోసం మాడ్యూళ్లు — మిక్సిన్‌లు ```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 ``` Ruby సింగిల్ ఇన్‌హెరిటెన్స్ కలిగి ఉన్నందున, సంబంధం లేని క్లాసుల్లో కోడ్ పునర్వినియోగం కోసం మాడ్యూళ్లు సమస్య సాధిస్తాయి: ఒక మాడ్యూల్ పద్ధతులను నిర్వచిస్తుంది, మరియు ఏదైనా క్లాస్ ఆ పద్ధతులను పొందడానికి దీన్ని `include` చేయవచ్చు. ఒక క్లాస్ **అనేక** మాడ్యూళ్లను చేర్చుకోవచ్చు — బహుళ వారసత్వానికి Ruby యొక్క సమాధానం. ## 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`** మాడ్యూల్ యొక్క పద్ధతులను ఇన్‌స్టాన్స్ పద్ధతులుగా జోడిస్తుంది; **`extend`** వాటిని క్లాస్ పద్ధతులుగా జోడిస్తుంది. ## నేమ్‌స్పేసింగ్ కోసం మాడ్యూళ్లు ```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 ``` మాడ్యూళ్లు **నేమ్‌స్పేసెస్** గా కూడా పనిచేస్తాయి, సంబంధిత క్లాసుల/స్థిరాంకాలను ఒక నామ కింద సమూహం చేస్తాయి (`Payments::Processor`) ఘర్షణలను నిరోధించడానికి. ## వాస్తవ-ప్రపంచ మిక్సిన్‌లు (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 యొక్క అంతర్నిర్మిత మిక్సిన్‌లు (**`Comparable`**, **`Enumerable`**) శక్తిశాలిగా ఉన్నాయి: ఒక పద్ధతిని (`<=>` లేదా `each`) అమలు చేయండి మరియు మాడ్యూల్ చాలా ఎక్కువ ఇవ్వుతుంది (పోలికలు, లేదా `map`/`select`/మొదలైనవి). ## ఇది ఎందుకు ముఖ్యమైనది మాడ్యూళ్లు మరియు మిక్సిన్‌లు ముఖ్యమైన, విలక్షణమైన Ruby లక్షణాలు, Ruby కోడ్ పునర్వినియోగం మరియు సంస్థ కోసం ప్రధానమైనవి, కాబట్టి వాటిని అర్థం చేసుకోవడం అవసరం. Ruby సింగిల్ ఇన్‌హెరిటెన్స్ కలిగి ఉన్నందున, **మిక్సిన్‌లు** (మాడ్యూళ్లను `include` ద్వారా క్లాసుల్లో చేర్చుకోవడం) సంబంధం లేని క్లాసుల్లో ప్రవర్తన భాగస్వామ్యం చేయడానికి Ruby యొక్క సొగసైన సమాధానం — ఒక క్లాస్ చాలా మాడ్యూళ్లను చేర్చుకుని వాటి పద్ధతులను పొందవచ్చు, బహుళ వారసత్వం యొక్క సమస్యలు లేకుండా దాని ప్రయోజనాలను అందిస్తుంది. ఇది Ruby కోడ్ (మరియు Rails) ఎలా నిర్మించబడిందో ప్రాథమికమైనది: క్రాస్-కటింగ్ ప్రవర్తన మాడ్యూళ్లలో ప్యాకేజీ చేయబడుతుంది మరియు దానిని కావలసిన క్లాసుల్లో మిశ్రమం చేయబడుతుంది. `include` (ఇన్‌స్టాన్స్ పద్ధతులు) vs `extend` (క్లాస్ పద్ధతులు) అర్థం చేసుకోవడం, మాడ్యూళ్లు **నేమ్‌స్పేసెస్** (సంబంధిత కోడ్ సమూహం ఘర్షణలను నిరోధించడానికి), మరియు ముఖ్యంగా Ruby యొక్క శక్తిశాలి అంతర్నిర్మిత మిక్సిన్‌లు (**`Comparable`** మరియు **`Enumerable`** — `<=>` లేదా `each` వంటి ఒక పద్ధతిని అమలు చేయడం ద్వారా మీకు చాలా పద్ధతులు ఉచితం), పునర్వినియోగపడే Ruby రాయడం మరియు మీరు ఉపయోగించే ఫ్రేమ్‌వర్క్ కోడ్ అర్థం చేసుకోవడం రెండింటికీ ముఖ్యమైనది. మాడ్యూళ్లు/మిక్సిన్‌లు Ruby ప్రవర్తన సొగసైన విధంగా కూర్చిందని, మరియు అవి ప్రామాణిక లైబ్రేరీ మరియు ఫ్రేమ్‌వర్క్‌ల్లో కనిపిస్తాయని. వాటిలో పारంగతత — కోడ్ భాగస్వామ్యం కోసం మిక్సిన్‌లు (Ruby యొక్క బహుళ-వారసత్వ ప్రత్యామ్నాయం), include vs extend, నేమ్‌స్పేసింగ్, మరియు Comparable/Enumerable లను ఉపయోగించడం — ముఖ్యమైన, తరచుగా-అన్వయించిన జ్ఞానం, Ruby యొక్క కూర్పు రూపకల్పన అర్థం ప్రతిబింబిస్తుంది మరియు ఇడియోమాటిక్, పునర్వినియోగపడే Ruby రాయడానికి అవసరమైనది మరియు సాధారణ ఇంటర్‌వ్యూ విషయం.