Ruby और Rails में मेथड डेलीगेशन में महारत: एक व्यावहारिक गाइड

यह लेख Ruby में मेथड डेलीगेशन के बारे में है।

आप delegate मेथड, Forwardable मॉड्यूल और SimpleDelegator क्लास का उपयोग करना सीखेंगे।

हमें डेलीगेशन की आवश्यकता क्यों है?

ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में, क्लासेज के एक साथ काम करने के दो तरीके हैं।

वे हैं:

• इनहेरिटेंस (विरासत)
• कंपोजिशन (संरचना)

इनहेरिटेंस के साथ, आप क्लास हायरार्की बनाते हैं, जहां एक पैरेंट क्लास किसी भी क्लास के साथ मेथड्स, कॉन्स्टेंट्स और इंस्टेंस वेरिएबल डेफिनिशन्स साझा करती है जो इससे इनहेरिट करती है।

उदाहरण के लिए:

Ruby में, हर ऑब्जेक्ट डिफ़ॉल्ट रूप से Object क्लास से इनहेरिट करता है।

इसीलिए आपको puts, class और object_id जैसे मेथड्स तक पहुंच मिलती है।

कंपोजिशन के साथ एक क्लास दूसरी क्लास के ऑब्जेक्ट्स बनाती है (या दी जाती है)... फिर यह उन ऑब्जेक्ट्स का उपयोग करके काम को उनको सौंप देती है।

उदाहरण के लिए:

एक कंप्यूटर कई पार्ट्स (ऑब्जेक्ट्स) से बना होता है और प्रत्येक पार्ट एक चीज अच्छी तरह से करना जानता है।

यदि आप स्क्रीन पर कुछ रेंडर करना चाहते हैं तो कंप्यूटर ग्राफिक्स कार्ड को बताएगा कि क्या दिखाना है, लेकिन यह नहीं कि कैसे करना है।

यही कंपोजिशन है!

लेकिन क्या होगा यदि आप कंप्यूटर हैं और आप ग्राफिक्स कार्ड के मेथड्स तक पहुंच देना चाहते हैं?

आपको उनके बीच किसी प्रकार का "पुल" बनाना होगा।

आइए देखते हैं कि यह कैसे करना है।

Ruby मेथड डेलीगेशन - उदाहरण

हमारे पास दो क्लासेज हैं:

• Computer
• Memory

निम्नलिखित कोड दिया गया है:

 class Computer def initialize @memory = Memory.new end end class Memory def initialize @data = [] end def write(data) @data << data end def read(index) @data[index] end end computer = Computer.new 

हम मेमोरी तक केवल Computer के माध्यम से पहुंचना चाहते हैं।

यह कई कारणों से हो सकता है:

• आपके पास केवल 1 मेमोरी यूनिट है, इसका मतलब है कि आप केवल 1 मेमोरी ऑब्जेक्ट चाहते हैं। एक ऑब्जेक्ट में एक्सेस को केंद्रीकृत करके आप इसे प्राप्त कर सकते हैं।
• आप नियंत्रित करना चाहते हैं कि मेमोरी तक कौन पहुंच सकता है (विभिन्न एप्लिकेशन्स) और वे मेमोरी के किन हिस्सों का उपयोग कर सकते हैं।
• आप सुरक्षा या डीबगिंग उद्देश्यों के लिए हर मेमोरी एक्सेस को लॉग करना चाहते हैं।

अब, यदि आप यह करने की कोशिश करते हैं:

 computer.write("rubyguides") 

यह NoMethodError के साथ फेल हो जाएगा क्योंकि Computer पर कोई write मेथड नहीं है।

 undefined method `write' for # (NoMethodError) 

Computer क्लास नहीं जानती कि आप write से क्या मतलब रखते हैं।

जब तक...

आप एक write मेथड बनाते हैं!

यहां कैसे:

 class Computer def initialize @memory = Memory.new end def write(data) @memory.write(data) end def read(index) @memory.read(index) end end 

हम रिक्वेस्ट्स को @memory ऑब्जेक्ट पर पास कर रहे हैं।

यह मेथड डेलीगेशन है।

नोट: यह इन मेथड्स को आपके पब्लिक इंटरफेस का हिस्सा बनाता है (वे सभी के लिए उपलब्ध हो जाते हैं) और आप हमेशा ऐसा नहीं चाहते।

क्या मेथड डेलीगेशन के लिए कोई शॉर्टकट है?

हाँ!

आइए एक नज़र डालते हैं...

Forwardable मॉड्यूल का उपयोग कैसे करें

अब:

आप Ruby के साथ शामिल Forwardable मॉड्यूल का उपयोग डेलीगेटर मेथड्स को परिभाषित करने के लिए कर सकते हैं।

यह ऐसे काम करता है:

 require 'forwardable' class Computer extend Forwardable def_delegators :@memory, :read, :write def initialize @memory = Memory.new end end 

यह आपको पहले बनाए गए मेथड्स को हटाने की अनुमति देता है और यह वही काम करेगा।

Forwardable आपके लिए मेथड आर्गुमेंट्स (ब्लॉक्स सहित!) का ख्याल रखेगा, इसलिए आपको उसकी चिंता नहीं करनी होगी।

क्या यह अच्छा नहीं है? 🙂

Rails Delegate मेथड का उपयोग कैसे करें

यदि आप Rails का उपयोग कर रहे हैं, या ActiveSupport जेम को अपने आप में, तो आपके पास delegate मेथड तक पहुंच है।

यह ऐसे काम करता है:

 class Computer delegate :read, :write, to: :@memory def initialize @memory = Memory.new end end 

delegate मेथड एक prefix आर्गुमेंट लेता है, जो आपको मेथड नामों में एक प्रीफिक्स जोड़ने की अनुमति देता है।

उदाहरण:

 class Computer delegate :read, :write, prefix: "memory", to: :@memory def initialize @memory = Memory.new end end 

परिणामस्वरूप दो मेथड्स:

• memory_read
• memory_write

SimpleDelegator के साथ सब कुछ डेलीगेट कैसे करें

ये तकनीकें जिन्हें आपने अभी सीखा है, विशिष्ट मेथड्स को फॉरवर्ड या डेलीगेट करने के लिए उपयोग की जाती हैं।

लेकिन यदि आप एक ऑब्जेक्ट को रैप करना चाहते हैं और इसके सभी मेथड्स को उजागर करना चाहते हैं...

आप SimpleDelegator क्लास का उपयोग कर सकते हैं!

यहां कैसे:

 require 'delegate' class CoolArray < SimpleDelegator end cool = CoolArray.new([]) cool << "ruby" cool << "gems" p cool 

अब CoolArray उस ऑब्जेक्ट की तरह व्यवहार करता है जिसे आप new में पास करते हैं।

यह उपयोगी क्यों है?

आप इस ऑब्जेक्ट में नए मेथड्स जोड़ सकते हैं, बिना मूल क्लास को बदले।

वीडियो ट्यूटोरियल

सारांश

आपने Ruby में ऑब्जेक्ट कंपोजिशन और विभिन्न तकनीकों का उपयोग करके मेथड्स को डेलीगेट करना सीखा!

यदि आपको यह लेख पसंद आया तो कृपया इसे अपने Ruby दोस्तों के साथ साझा करें।

पढ़ने के लिए धन्यवाद 🙂