दिलचस्प पोस्ट
शब्दकोश में अजगर पांडा डेटाफ़्रेम विज़ुअल सी ++ 2008 में एक यूटीएफ -8 स्ट्रिंग कैसे बनाऊं विंडोज पर .gitconfig स्थान बदल रहा है सी के लिए XML पार्सर स्विफ्ट में स्थानीय स्कोप कैसे बनाएं? zlib.error: त्रुटि 3 जबकि विघटित करना: गलत हेडर चेक मैं नल को अनुमति देने के लिए एक MySQL स्तंभ को कैसे संशोधित करूं? क्या मैं इस मैक्रो को अधिक कुशल या तेज बना सकता हूँ? जेएसएएन के साथ एचटीपी 415 असमर्थित मीडिया प्रकार त्रुटि आईओएस एप्लिकेशन स्प्लैश स्क्रीन के लिए आकार क्या है? मुझे अभी पता चला है कि सभी एएसपी.नेट वेबसाइट धीमे क्यों हैं, और मैं इस बारे में काम करने की कोशिश कर रहा हूं स्विफ्ट में सबस्क्रिप्ट और सुपरस्क्रिप्ट का उपयोग कैसे करें स्विच / पैटर्न मिलान विचार आईफोन ऐड हाक एक्सकोड 4 का इस्तेमाल कर रहा है गिट में आखिरी प्रतिबद्धता को कैसे पूर्ववत करें?

रूबी मॉड्यूल में प्रत्येक विधि कॉल के लिए कोड कार्यान्वित करना

मैं रूबी 1.9.2 में एक मॉड्यूल लिख रहा हूं जो कि कई तरीकों को परिभाषित करता है। जब इन विधियों में से कोई भी कहा जाता है, तो मैं चाहता हूं कि उनमें से प्रत्येक को पहले एक निश्चित बयान निष्पादित करना चाहिए।

module MyModule def go_forth a re-used statement # code particular to this method follows ... end def and_multiply a re-used statement # then something completely different ... end end 

लेकिन मैं यह सुनिश्चित करना चाहता हूं कि हर एक विधि में a re-used statement कोड को स्पष्ट रूप से निर्दिष्ट करना चाहिए। ऐसा करने का एक तरीका है?

(यदि यह मायने रखता है, a re-used statement में प्रत्येक विधि होगा, जिसे बुलाया जाता है, अपना अपना नाम मुद्रित करता है। ऐसा कुछ puts __method__ माध्यम से puts __method__ को puts __method__ ।)

वेब के समाधान से एकत्रित समाधान "रूबी मॉड्यूल में प्रत्येक विधि कॉल के लिए कोड कार्यान्वित करना"

इस कदर:

 module M def self.before(*names) names.each do |name| m = instance_method(name) define_method(name) do |*args, &block| yield m.bind(self).(*args, &block) end end end end module M def hello puts "yo" end def bye puts "bum" end before(*instance_methods) { puts "start" } end class C include M end C.new.bye #=> "start" "bum" C.new.hello #=> "start" "yo" 

यह वास्तव में किस पहलू के लिए बनाया गया है।

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

 require 'aspector' module MyModule aspector do before :go_forth, :add_multiply do ... end end def go_forth # code particular to this method follows ... end def and_multiply # then something completely different ... end end 

मुझे नहीं पता है कि मुझे निराश क्यों किया गया था – लेकिन मेटा-प्रोग्रामिंग हैकरी से बेहतर एओपी ढांचा बेहतर है और ओपी क्या हासिल करने की कोशिश कर रहा था

http://debasishg.blogspot.com/2006/06/does-ruby-need-aop.html

एक और समाधान हो सकता है:

 module Aop def self.included(base) base.extend(ClassMethods) end module ClassMethods def before_filter(method_name, options = {}) aop_methods = Array(options[:only]).compact return if aop_methods.empty? aop_methods.each do |m| alias_method "#{m}_old", m class_eval <<-RUBY,__FILE__,__LINE__ + 1 def #{m} #{method_name} #{m}_old end RUBY end end end end module Bar def hello puts "Running hello world" end end class Foo include Bar def find_hello puts "Running find hello" end include Aop before_filter :find_hello, :only => :hello end a = Foo.new() a.hello() 

आप प्रॉक्सी मॉड्यूल के माध्यम से method_missing साथ इसे लागू कर सकते हैं, जैसे:

 module MyModule module MyRealModule def self.go_forth puts "it works!" # code particular to this method follows ... end def self.and_multiply puts "it works!" # then something completely different ... end end def self.method_missing(m, *args, &block) reused_statement if MyModule::MyRealModule.methods.include?( m.to_s ) MyModule::MyRealModule.send(m) else super end end def self.reused_statement puts "reused statement" end end MyModule.go_forth #=> it works! MyModule.stop_forth #=> NoMethodError... 

आप मेटाप्रोग्राफिक तकनीक द्वारा यह कर सकते हैं, यहां एक उदाहरण है:

 module YourModule def included(mod) def mod.method_added(name) return if @added @added = true original_method = "original #{name}" alias_method original_method, name define_method(name) do |*args| reused_statement result = send original_method, *args puts "The method #{name} called!" result end @added = false end end def reused_statement end end module MyModule include YourModule def go_forth end def and_multiply end end 

केवल रब्बी 1.9 और उच्चतर में काम करता है

अद्यतन: और ब्लॉक का भी उपयोग नहीं कर सकते हैं, अर्थात उदाहरण के तरीकों में कोई उपज नहीं

यह मेटा-प्रोग्रामिंग के साथ संभव है

एक अन्य विकल्प मछलीघर है एक्वेरियम एक रूपरेखा है जो रूबी के लिए पहलू-उन्मुख प्रोग्रामिंग (एओपी) लागू करता है। एओपी आप सामान्य ऑब्जेक्ट और विधि सीमाओं में कार्यक्षमता को लागू करने की अनुमति देते हैं। आपके उपयोग के मामले में, प्रत्येक विधि पर पूर्व-कार्य लागू करने, एओपी का एक बुनियादी कार्य है