મોડ્યુલ્સ અને મિક્સિન્સ શું છે?

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 એક જ વારસાગત ધરાવતો હોવાથી **single inheritance**, મોડ્યુલ્સ સંબંધિત ક્લાસીસમાં કોડ પુનઃઉપયોગ ઉકેલે છે: એક મોડ્યુલ મેથડ્સ વ્યાખ્યાયિત કરે છે, અને કોઈપણ ક્લાસ તે મોડ્યુલ `include` કરી શકે તે મેથડ્સ મેળવવા માટે. એક ક્લાસ **ઘણા** મોડ્યુલ્સ શામેલ કરી શકે છે — Ruby માટે બહુવિધ વારસાગતનો જવાબ. ## include વિશે 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 એક જ વારસાગત ધરાવતો હોવાથી **single inheritance**, **મિક્સિન્સ** (મોડ્યુલ્સને `include` દ્વારા ક્લાસીસમાં શામેલ કરવો) સંબંધિત ક્લાસીસમાં વર્તણૂક શેર કરવાનો Ruby નો સુંદર ઉકેલ છે — એક ક્લાસ એકથી વધુ મોડ્યુલ્સ શામેલ કરી શકે તેમના મેથડ્સ મેળવવા માટે, બહુવિધ વારસાગતના લાભો પ્રદાન કર્યા વિના તેની સમસ્યાઓ વિના. actresses Ruby કોડ (અને Rails) કેવી રીતે બંધાયેલ છે તેનું ફંડામેન્ટલ છે: ક્રોસ-કટીંગ વર્તણૂક મોડ્યુલમાં પેક કરવામાં આવે છે અને તે ક્લાસીસમાં મિશ્રિત કરવામાં આવે છે જેમને તે જરૂર છે. `include` (ઈન્સ્ટન્સ મેથડ્સ) વિશે `extend` (ક્લાસ મેથડ્સ), મોડ્યુલ્સ જેમ **નેમસ્પેસ** (સંબંધિત કોડ જૂથીકૃત કરવા ટકરાણ ટાળવા માટે), અને વિશેષ કરીને Ruby ના શક્તિશાળી બિલ્ટ-ઈન મિક્સિન્સ (**`Comparable`** અને **`Enumerable`** — જ્યાં એક મેથડ `<=>` અથવા `each` જેવું લાગુ કરવો તમને ઘણા મેથડ્સ મુક્તમાં આપે છે) સમજવું પુનઃઉપયોગી Ruby લખવા અને તમે જે ફ્રેમવર્ક કોડ ઉપયોગ કરો છો તે સમજવા બંને માટે મહત્ત્વપૂર્ણ છે. મોડ્યુલ્સ/મિક્સિન્સ તે રીતે છે Ruby સુંદરતાથી વર્તણૂક રચે છે, અને તે સ્ટાન્ડર્ડ લાઇબ્રેરી અને ફ્રેમવર્ક્સ માં દેખાય છે. તેમમાં માસ્ટરી — કોડ શેર કરવા માટે મિક્સિન્સ (Ruby ની બહુવિધ-વારસાગત વિકલ્પ), include વિશે extend, નેમસ્પેસીંગ, અને Comparable/Enumerable નો લાભ લેવો — મહત્ત્વપૂર્ણ, વારંવાર-લાગુ જ્ઞાન છે જે Ruby ની કમ્પોઝીશનલ ડિઝાઈન સમજવું પ્રતિબિંબિત કરે છે અને idiomatic, પુનઃઉપયોગી Ruby લખવા માટે જરૂરી છે અને સામાન્ય ઈન્ટરવ્યુ વિષય છે.