रूबी के साथ रूबी का विस्तार: पायथन से फ़ंक्शन डेकोरेटर्स उधार लेना

अनुवादक से: मेरा सुझाव है कि आप माइकल फेयरली की प्रस्तुति की शुरुआत का अनुवाद करें - रूबी के साथ रूबी का विस्तार । मैंने तीनों में से केवल पहले भाग का अनुवाद किया, क्योंकि इसमें मेरी राय में अधिकतम व्यावहारिक मूल्य और लाभ है। फिर भी, मैं दृढ़ता से अनुशंसा करता हूं कि आप पूरी प्रस्तुति पढ़ें, जो कि पायथन के अलावा हास्केल और स्काला से उधार लेने वाले चिप्स के उदाहरण प्रदान करता है।

समारोह सज्जाकार

पायथन में एक ऐसी चीज है - सज्जाकार, जो विधियों और कार्यों के लिए अक्सर उपयोग की जाने वाली कार्यक्षमता के टुकड़ों को जोड़ने के लिए सिंथेटिक चीनी है। अब मैं आपको कुछ उदाहरण दिखाऊंगा कि सज्जाकार क्या हैं और वे रूबी में क्यों उपयोगी हो सकते हैं।

मैं पायथन के साथ बहुत काम करता था, और फंक्शन डेकोरेटर्स निश्चित रूप से एक ऐसी चीज है जो मैं तब से गायब है, और इसके अलावा हम लगभग सभी को अपना रूबी कोड क्लीनर बनाने में मदद कर सकते हैं।

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

def send_money(from, to, amount) from.balance -= amount to.balance += amount from.save! to.save! end 

हम खाते से "शेष" राशि को काट लेते हैं ...

 from.balance -= amount 

और हम इस राशि को "खाते" के शेष राशि में जोड़ते हैं ...

 to.balance += amount 

और दोनों अकाउंट को सेव करें।

 from.save! to.save! 

लेकिन कुछ कमियां हैं, जिनमें से सबसे स्पष्ट है एक लेन-देन की कमी (यदि " from.save! " सफल होती है , लेकिन " to.save! " नहीं करता है, तो पैसा हवा में घुल जाएगा)।

सौभाग्य से, ActiveRecord इस समस्या का समाधान बहुत सरल बनाता है। हम बस एक लेनदेन विधि के ब्लॉक में अपना कोड लपेटते हैं और यह हमें गारंटी देता है कि ब्लॉक के अंदर सब कुछ या तो सफलतापूर्वक समाप्त होता है या नहीं।

 def send_money(from, to, amount) ActiveRecord::Base.transaction do from.balance -= amount to.balance += amount from.save! to.save! end end 

आइए अब उसी उदाहरण को पायथन में देखें। एक लेनदेन के बिना एक संस्करण लगभग रूबी में जैसा दिखता है।

 def send_money(from, to, amount): from.balance -= amount to.balance += amount from.save() to.save() 

लेकिन यह एक लेन-देन को जोड़ने के लायक है और कोड अब बहुत सुंदर नहीं लग रहा है।

 def send_money(from, to, amount): try: db.start_transaction() from.balance -= amount to.balance += amount from.save() to.save() db.commit_transaction() except: db.rollback_transaction() raise 

इस पद्धति में कोड की 10 लाइनें हैं, लेकिन उनमें से केवल 4 हमारे व्यावसायिक तर्क को लागू करते हैं।

 from.balance -= amount to.balance += amount from.save() to.save() 

अन्य 6 लाइनें लेन-देन के अंदर हमारे तर्क को लॉन्च करने के लिए एक टेम्पलेट हैं। यह बदसूरत और बहुत क्रियात्मक है, लेकिन इससे भी बदतर - आपको इन सभी लाइनों को याद रखना होगा, जिसमें सही त्रुटि हैंडलिंग और रोलबैक शब्दार्थ भी शामिल है।

 def send_money(from, to, amount): try: db.start_transaction() ... db.commit_transaction() except: db.rollback_transaction() raise 

तो हम इसे और अधिक सुंदर कैसे बनाते हैं और खुद को कम दोहराते हैं? पायथन में कोई ब्लॉक नहीं हैं, इसलिए रूबी की तरह एक फोकस यहां काम नहीं करेगा। हालांकि, पायथन में आसानी से गुजरने और पुन: असाइन करने की क्षमता है। इसलिए, हम " ट्रांसेक्शनल " फ़ंक्शन लिख सकते हैं, जो दूसरे फ़ंक्शन को एक तर्क के रूप में ले जाएगा और उसी फ़ंक्शन को वापस कर देगा, लेकिन पहले से ही टेम्पलेट लेनदेन कोड में लिपटे हुए हैं।

 def send_money(from, to, amount): from.balance -= amount to.balance += amount from.save() to.save() send_money = transactional(send_money) 

और यहां बताया गया है कि ट्रांसेक्शनल फ़ंक्शन कैसे दिख सकता है ...

 def transactional(fn): def transactional_fn(*args): try: db.start_transaction() fn(*args) db.commit_transaction() except: db.rollback_transaction() raise return transactional_fn 

यह अपने एकमात्र तर्क के रूप में एक फ़ंक्शन (" send_money " हमारे उदाहरण में) प्राप्त करता है।

 def transactional(fn): 

एक नया कार्य परिभाषित करता है।

 def transactional_fn(*args): 

नए फ़ंक्शन में लेन-देन में व्यावसायिक तर्क को लपेटने के लिए एक टेम्पलेट होता है।

 try: db.start_transaction() ... db.commit_transaction() except: db.rollback_transaction() raise 

टेम्पलेट के अंदर, मूल फ़ंक्शन को कहा जाता है, जो नए फ़ंक्शन को दिए गए तर्कों को पास करता है।

 fn(*args) 

अंत में, नया फीचर वापस आ गया है।

 return transactional_fn 

इस प्रकार, हम send_money फ़ंक्शन को ट्रांसेक्शनल फ़ंक्शन में पास करते हैं जिसे हमने अभी परिभाषित किया है, जो बदले में एक नया फ़ंक्शन देता है जो Send_money फ़ंक्शन के समान कार्य करता है, लेकिन यह सभी लेनदेन के अंदर करता है। और फिर हम अपनी मूल सामग्री को ओवरराइड करते हुए इस नए फ़ंक्शन को हमारे send_money फ़ंक्शन पर असाइन करते हैं। अब, जब भी हम send_money फ़ंक्शन को कॉल करते हैं, तो लेनदेन संस्करण कहा जाएगा।

 send_money = transactional(send_money) 

और यही मैं इस समय का नेतृत्व कर रहा हूं। यह मुहावरा अक्सर पायथन में उपयोग किया जाता है कि एक विशेष वाक्यविन्यास, एक फ़ंक्शन डेकोरेटर, इसे समर्थन करने के लिए जोड़ा गया है। और यह है कि कैसे आप Django ORM में कुछ लेनदेन करते हैं।

 @transactional def send_money(from, to, amount): from.balance -= amount to.balance += amount from.save() to.save() 

तो क्या?

अब आप सोच रहे हैं, “तो क्या? आपने अभी दिखाया कि यह सजाने वाला मुंबा-युम्बा उसी समस्या को हल करता है जो हल करती है। हमें रूबी में इस टोपी की आवश्यकता क्यों है? ”ठीक है, आइए एक नज़र डालते हैं उस मामले पर जिसमें ब्लॉक अब इतने सुरुचिपूर्ण नहीं दिखते।

आइए एक विधि है जो फाइबोनैचि अनुक्रम में nth तत्व के मूल्य की गणना करता है।

 def fib(n) if n <= 1 1 else fib(n - 1) + fib(n - 2) end end 

वह धीमा है, इसलिए हम उसे याद करना चाहते हैं। इसके लिए आम तौर पर स्वीकार किया गया दृष्टिकोण " = = " हर जगह है, जो एक लेनदेन के साथ पहले उदाहरण के रूप में एक ही बीमारी से ग्रस्त है - हम अपने एल्गोरिथ्म के कोड को अतिरिक्त व्यवहार के साथ मिलाते हैं जिसे हम इसके साथ घेरना चाहते हैं।

 def fib(n) @fib ||= {} @fib[n] ||= if n <= 1 1 else fib(n - 1) + fib(n - 2) end end 

इसके अलावा, हम यहां कुछ चीजों को भूल गए, जैसे कि यह तथ्य कि "नील" और "गलत" को इस तरह से याद नहीं किया जा सकता है: एक और बिंदु जिसे लगातार याद रखना चाहिए।

 def fib(n) @fib ||= {} return @fib[n] if @fib.has_key?(n) @fib[n] = if n <= 1 1 else fib(n - 1) + fib(n - 2) end end 

ठीक है, हम इसे एक ब्लॉक के साथ हल कर सकते हैं, लेकिन ब्लॉक के पास फ़ंक्शन के नाम या तर्कों तक पहुंच नहीं है जो उन्हें कॉल करते हैं, इसलिए हमें इस जानकारी को स्पष्ट रूप से पास करना होगा।

 def fib(n) memoize(:fib, n) do if n <= 1 1 else fib(n - 1) + fib(n - 2) end end end 

और अब, अगर हम कोर कार्यक्षमता के आसपास और अधिक ब्लॉक जोड़ना शुरू करते हैं ...

 def fib(n) memoize(:fib, n) do time(:fib, n) do if n <= 1 1 else fib(n - 1) + fib(n - 2) end end end end 

... हम बार-बार विधि के नाम और उसके तर्कों को फिर से लिखने के लिए मजबूर होंगे।

 def fib(n) memoize(:fib, n) do time(:fib, n) do synchronize(:fib) do if n <= 1 1 else fib(n - 1) + fib(n - 2) end end end end end 

यह एक नाज़ुक निर्माण है और यह उसी क्षण टूट जाएगा जब हम किसी भी तरह से विधि हस्ताक्षर को बदलने का फैसला करेंगे।

फिर भी, हमारी पद्धति की परिभाषा के ठीक बाद इस तरह की चीज़ को जोड़कर इसे हल किया जा सकता है।

 def fib(n) if n <= 1 1 else fib(n - 1) + fib(n - 2) end end ActiveSupport::Memoizable.memoize :fib 

और यह आपको याद दिलाना चाहिए कि हमने पायथन में क्या देखा था - जब विधि का संशोधन स्वयं विधि के तुरंत बाद चला गया।

 # Ruby def fib(n) ... end ActiveSupport::Memoizable.memoize :fib # Python def fib(n): ... fib = memoize(fib) 

क्यों पायथन समुदाय इस समाधान की तरह नहीं था? दो कारण:

• अब आप अपने कोड के निष्पादन को ऊपर से नीचे तक ट्रैक नहीं कर सकते हैं;
• कहीं भी विधि को स्थानांतरित करना बहुत आसान है और इसके बाद आए कोड के साथ इसे करना न भूलें।

आइए पायथन में हमारे फिबोनाची उदाहरण को देखें।

 def fib(n): if n <= 1: return 1 else return fib(n - 1) + fib(n - 2) 

हम इसे याद रखना चाहते हैं, इसलिए हम इसे मेमोइज़ फ़ंक्शन के साथ सजाते हैं।

 @memoize def fib(n): if n <= 1: return 1 else return fib(n - 1) + fib(n - 2) 

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

 @synchronize @time @memoize def fib(n): if n <= 1: return 1 else return fib(n - 1) + fib(n - 2) 

और अब मैं आपको दिखाऊंगा कि रूबी में इसे कैसे प्राप्त किया जा सकता है ("@" के बजाय "+" का उपयोग करके और बड़े अक्षर के रूप में पहला अक्षर)। और सबसे मजेदार बात यह है कि हम इस डेकोरेटर सिंटैक्स को रूबी में जोड़ सकते हैं, जो कि पायथन में सिंटैक्स के बहुत करीब है, कोड की सिर्फ 15 पंक्तियों के साथ।

 +Synchronized +Timed +Memoized def fib(n) if n <= 1 1 else fib(n - 1) + fib(n - 2) end end 

डुबकी

आइए अपने send_money उदाहरण पर वापस जाएं। हम इसमें ट्रांजेक्शनल डेकोरेटर जोड़ना चाहते हैं।

 +Transactional def send_money(from, to, amount) from.balance -= amount to.balance += amount from.save! to.save! end 

Transactional डेकोरेटर का एक उपवर्ग है, जिसके बारे में हम नीचे चर्चा करते हैं।

 class Transactional < Decorator def call(orig, *args, &blk) ActiveRecord::Base.transaction do orig.call(*args, &blk) end end end 

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

 def call(orig, *args, &blk) 

हम एक लेन-देन खोलते हैं।

 ActiveRecord::Base.transaction do 

और फिर हम लेनदेन ब्लॉक के अंदर मूल विधि कहते हैं।

 orig.call(*args, &blk) 

ध्यान दें कि हमारे डेकोरेटर की संरचना पाइथन में डेकोरेटर के काम करने के तरीके से अलग है। तर्कों को प्राप्त करने वाले एक नए फ़ंक्शन को परिभाषित करने के बजाय, हमारे रूबी डेकोरेटर को हर कॉल के साथ स्वयं और उसके तर्कों को विधि प्राप्त होगी। रूबी में वस्तुओं के लिए बाध्यकारी तरीकों के शब्दार्थ के कारण हमें ऐसा करने के लिए मजबूर किया जाता है, जिसके बारे में हम नीचे बात करेंगे।

कक्षा " डेकोरेटर " के अंदर क्या है?

 class Decorator def self.+@ @@decorator = self.new end def self.decorator @@decorator end def self.clear_decorator @@decorator = nil end end 

यह चीज़, " + @ ", "यूनीरी प्लस" ऑपरेटर है, इसलिए इस पद्धति को तब बुलाया जाएगा जब हम + डेकोरेटरनाम को कॉल करेंगे, जैसा कि हमने + लेन-देन के साथ किया था।

 def self.+@ 

हमें वर्तमान डेकोरेटर को प्राप्त करने का एक तरीका भी चाहिए।

 def self.decorator @@decorator end 

और वर्तमान डेकोरेटर को रीसेट करने का एक तरीका।

 def self.clear_decorator @@decorator = nil end 

एक वर्ग जो सजाने के तरीकों को चाहता है, उसे मेथडेकटोरर्स मॉड्यूल द्वारा बढ़ाया जाना चाहिए।

 class Bank extend MethodDecorators +Transactional def send_money(from, to, amount) from.balance -= amount to.balance += amount from.save! to.save! end end 

तुरंत क्लास क्लास का विस्तार करना संभव होगा, लेकिन मुझे लगता है कि इस मामले में सबसे अच्छा अभ्यास इस तरह के निर्णय को अंतिम उपयोगकर्ता के विवेक पर छोड़ना होगा।

 module MethodDecorators def method_added(name) super decorator = Decorator.decorator return unless decorator Decorator.clear_decorator orig_method = instance_method(name) define_method(name) do |*args, &blk| m = orig_method.bind(self) decorator.call(m, *args, &blk) end end end 

" Method_added " एक वर्ग का एक निजी तरीका है जिसे हर बार एक नई विधि को कक्षा में परिभाषित किया जाता है, जिससे हमें विधि बनाने के लिए पकड़ने का एक सुविधाजनक तरीका मिल जाता है।

 def method_added(name) 

पैरेंट मेथड_डेड को कॉल करें। आप " method_added ", " method_missing " या " response_to " जैसी विधियों को ओवरराइड करके इसे आसानी से भूल सकते हैं ? "लेकिन अगर आप नहीं करते हैं, तो आप आसानी से अन्य पुस्तकालयों को तोड़ सकते हैं।

 super 

हम वर्तमान डेकोरेटर को प्राप्त करते हैं और यदि कोई डेकोरेटर नहीं है, तो फ़ंक्शन को समाप्त कर दें, अन्यथा वर्तमान डेकोरेटर को शून्य करें। डेकोरेटर को रीसेट करना महत्वपूर्ण है, क्योंकि तब हम विधि को फिर से परिभाषित करते हैं, जो फिर से हमारे " method_added " को कॉल करता है।

 decorator = Decorator.decorator return unless decorator Decorator.clear_decorator 

हम विधि का मूल संस्करण निकालते हैं।

 orig_method = instance_method(name) 

और इसे फिर से परिभाषित करें।

 define_method(name) do |*args, &blk| 

" Instance_method " वास्तव में " UnboundMethod " वर्ग की एक वस्तु देता है, जो एक ऐसी विधि है जो यह नहीं जानती है कि यह किस वस्तु से संबंधित है, इसलिए हमें इसे वर्तमान वस्तु से बांधना चाहिए।

 m = orig_method.bind(self) 

और फिर हम डेकोरेटर को बुलाते हैं, इसे मूल विधि और इसके लिए तर्क देते हैं।

 decorator.call(m, *args, &blk) 

और क्या?

बेशक, इस कोड को उत्पादन के लिए तैयार माना जा सकता है इससे पहले कि अविश्वसनीय रूप से महत्वपूर्ण बिंदुओं का एक नंबर है, जिसे हल किया जाना चाहिए।

कई सज्जाकार

जिस कार्यान्वयन का मैंने हवाला दिया, वह हमें प्रत्येक विधि के लिए केवल एक डेकोरेटर का उपयोग करने की अनुमति देता है, लेकिन हम एक से अधिक डेकोरेटर का उपयोग करने में सक्षम होना चाहते हैं।

 +Timed +Memoized def fib(n) ... end 

क्षेत्र

Define_method सार्वजनिक विधियों को परिभाषित करता है, लेकिन हम निजी और संरक्षित तरीके चाहते हैं, जिन्हें उनके दायरे के संबंध में सजाया जा सकता है।

 private +Transactional def send_money(from, to, amount) ... end 

क्लास के तरीके

" Method_added " और " define_method " केवल कक्षा उदाहरण के तरीकों के लिए काम करते हैं, इसलिए आपको कुछ और के साथ आने की जरूरत है ताकि सज्जाकार वर्ग के तरीकों के लिए काम करें।

 +Memoize def self.calculate ... end 

बहस

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

 +Retry.new(3) def post_to_facebook ... end 

मणि स्थापित method_decorators

github.com/michaelfairley/method_decorators

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