मुझे डेलिगेटक्लास से प्यार हो गया

यदि आपकी कक्षा इतनी बढ़ गई है कि वह एक एकल कर्तव्य के सिद्धांत का उल्लंघन करना शुरू कर देता है , तो आप इसे आसानी से कई और जुड़े वर्गों में विभाजित कर सकते हैं। रूबी द्वारा प्रदान किया गया DelegateClass निर्माण आपको इसमें मदद करेगा।

मान लीजिए कि आपके पास एक Person वर्ग है। सिस्टम में उपयोगकर्ता कुछ बेच सकते हैं और / या लेख प्रकाशित कर सकते हैं। उपवर्गों का उपयोग यहां नहीं किया जा सकता है, क्योंकि उपयोगकर्ता एक ही समय में लेखक और विक्रेता दोनों हो सकते हैं। आइए रिफ्लेक्टर।

आपकी कक्षा शुरू में कुछ इस तरह दिखती है:

 class Person < ActiveRecord::Base has_many :articles #  has_many :comments, :through => :articles #  has_many :items #  has_many :transactions #  # ? def is_seller? items.present? end #    def amount_owed # =>   end # ? def is_author? articles.present? end #     ? def can_post_article_to_homepage? # =>       end end 

ऐसा लगता है कि सब कुछ अच्छा लग रहा है। आप कहते हैं, "उपयोगकर्ता को यह जानने की जरूरत है कि उपयोगकर्ता ने कितनी चीजें बेचीं और कितने लेख प्रकाशित किए।" "बकवास," मैं जवाब दूंगा।

इसमें एक नई चुनौती आ रही है: उपयोगकर्ता विक्रेता / लेखक और खरीदार दोनों हो सकते हैं। इस कार्य को पूरा करने के लिए, आपको अपना वर्ग बदलना होगा, उदाहरण के लिए इस तरह:

 class Person < ActiveRecord::Base # ... has_many :purchased_items #   has_many :purchased_transactions #   # ? def is_buyer? purchased_items.present? end # ... end 

सबसे पहले, आपने खुलेपन / निकटता (विस्तार के लिए खुलापन, लेकिन परिवर्तनों के लिए बंद) के सिद्धांत का उल्लंघन किया, क्योंकि आपने वर्ग बदल दिया। दूसरे, जब बिक्री / खरीदारी करते हैं, तो वर्ग के नाम स्पष्ट नहीं होंगे ("उपयोगकर्ता उपयोगकर्ता को बेचता है", "विक्रेता खरीदार को बेचता है") तो बेहतर होगा। अंत में, कोड साझा जिम्मेदारी के सिद्धांत का उल्लंघन करता है।

अब कल्पना कीजिए कि एक नई चुनौती आ गई है। उपयोगकर्ताओं को एक संबंध में नहीं, बल्कि NoSQL डेटाबेस में, या XML के माध्यम से एक वेब सेवा से प्राप्त किया जाना चाहिए। आप ActiveRecord की सुविधा से वंचित हैं, ये सभी has_many अब काम नहीं करते हैं। वास्तव में, आपको कक्षा को स्क्रैच से फिर से लिखने की आवश्यकता है, नई कार्यक्षमता का विकास स्थगित है।

मिलो: डेलिगेटक्लास

Person वर्ग को बदलने के बजाय, प्रतिनिधि वर्गों की मदद से इसकी कार्यक्षमता का विस्तार किया जा सकता है:

 #  class Person < ActiveRecord::Base end #  class Seller < DelegateClass(Person) delegate :id, :to => :__getobj__ #  def items Item.for_seller_id(id) end #  def transactions Transaction.for_seller_id(id) end # ? def is_seller? items.present? end #    def amount_owed # =>   end end #  class Author < DelegateClass(Person) delegate :id, :to => :__getobj__ #  def articles Article.for_author_id(id) end #  def comments Comment.for_author_id(id) end #  def is_author? articles.present? end #     ? def can_post_article_to_homepage? # =>       end end 

इन वर्गों का उपयोग करने के लिए, आपको थोड़ा और कोड लिखना होगा। के बदले

 person = Person.find(1) person.items 

इस कोड का उपयोग करें:

 person = Person.find(1) seller = Seller.new(person) seller.items seller.first_name # =>  person.first_name 

अब उपयोगकर्ताओं को अधिक ग्राहक बनाना आसान है:

 #  class Buyer < DelegateClass(Person) delegate :id, :to => :__getobj__ #   def purchased_items Item.for_buyer_id(id) end # ? def is_buyer? purchased_items.present? end end 

अब अगर आपको ActiveRecord से Mongoid तक स्विच करना है, तो आपको डेलिगेट वर्गों में कुछ भी बदलने की आवश्यकता नहीं है।

बेशक, प्रतिनिधि वर्ग एक चांदी की गोली नहीं है। कुछ तरीकों के हमेशा स्पष्ट व्यवहार के लिए इस्तेमाल होने में कुछ समय नहीं लगता है, उदाहरण के लिए, #reload :

 person = Person.find(1) seller = Seller.new(person) seller.class # => Seller seller.reload.class # => Person 

एक और #id यह है कि, डिफ़ॉल्ट रूप से, #id विधि को प्रत्यायोजित नहीं किया जाता है। बिल्कुल AcitveRecord#id प्राप्त करने के लिए, इस लाइन को AcitveRecord#id वर्ग में जोड़ें:

 delegate :id, :to => :__getobj__ 

इसके बावजूद, कोड लचीलेपन को बढ़ाने के लिए प्रतिनिधि कक्षाएं एक महान उपकरण हैं।

---

अनुवादक से : सर्गेई पोतापोव डेलिगेटक्लास की एक और गैर-स्पष्ट विशेषता बताते हैं :

 require 'delegate' class Animal end class Dog < DelegateClass(Animal) end animal = Animal.new dog = Dog.new(animal) dog.eql?(dog) # => false, WTF? O_o 

क्या यह इस तथ्य के कारण है कि #eql? आधार वस्तु (इस मामले में, animal ) के लिए कहा जाता है:

 dog.eql?(animal) # => true 

दूसरी ओर, #equal? डिफ़ॉल्ट रूप से प्रत्यायोजित नहीं:

 dog.equal?(dog) # => true dog.equal?(animal) # => false