RoR - MetaProgramming

Posted 2021-02-16 vixennn

ruby是动态语言，它有动态语言的优势与劣势

动态语言，像python与ruby 你不用提前去定义method - they need to only be "found" when invoked

calling method dynamically: 

class Dog
    def bark
         puts "Woof, woof!‘
    end
    def greet(greeting)
        puts greeting
    end
end

dog = Dog.new
dog.bark # => Woof, woof!
dog.send("bark") # => Woof, woof!
dog.send(:bark) # => Woof, woof!
method_name = :bark
dog.send method_name # => Woof, woof!

dog.send(:greet, "hello") # => hello

　　Dynamic Dispatch:

　　不需要call method 用 xxx.xxx 

　　能用string和symbol call methods dynamically

 

优点：*can decide at runtime which methods to call 

           *The code doesn‘t have to find out until runtime which method it needs to call 

 

Dynamic method： 

class Whatever 
    define_method :make_it_up do 
        puts "Whatever..."
    end
end

whatever = Whatever.new 
whatever.make_it_up # => Whatever...

写动态方法能有效降低code量

require_relative ‘store‘
class ReportingSystem 

    def initialize 
        @store = Store.new 
        @store.methods.grep(/^get_(.*)_desc/) { ReportingSystem.define_report_method_for $1 )
    end

    def self.define_repot_methods_for (item)
        define_method ("get_#{item}_desc") {@store.send("get_#{item}_desc) }
        define_method ("get_#{item}_price") {@store.send("get_#{item}_desc) }
    end   
end

r3 = ReportingSystem.new 
puts "#{rs.get_piano_desc} costs #{rs.get_piano_price.to_s.ljust(6.‘0‘)}"

# => Excellent piano costs 120.00

 

Ghost method: 

如果我们使用了不存在的method，会自动跳转到method_missing  method，不过method_missing 可以被复写：

class Mystery 
    #no_methods defined 
    def method_missing (method, *args)
        puts "Looking for..."
        puts ""#{method}" with params {#{args.join(‘,‘)}} ?"
        puts "Sorry... He is on vacation... "
        yield "Ended up in method_missing" if block_given?
    end
end 

m = Mystery.new 
m.solve_mystery("abc", 123123) do |answer|
    puts "And the answer is: #{answer}" 
end

# =>  Looking for...
# =>  "solve_mystery" with params (abc,123123) ?
# =>  Sorry... He is on vacation...
# =>  And the answer is: Ended up in method_missing

* method_missing gives you the power to "fake" the methods

* 这被叫做ghost methods 是因为 它并不真正意义上的存在

*ruby built-in classes use method_missing and dynamic methods all over the place... 

 

Struct and OpenStruct:

Struct: 特定类的生成器，每个类都被定义为保存一组变量及其访问器（动态
方法)

OpenStruct: 对象（类似于Struct），其属性在第一次分配时动态创建（“Ghost方法”）。

Customer = Struct.new(:name, :address) do #block is optional 
    def to_s 
        "#{name} lives at #{address}"
    end
end 
jim = Customer.new("Jim", "-1000 wall Street")
puts jim # => Jim lives at -1000 wall Street


require ‘ostruct‘ # => need to require ostruct for OpenStruct 

some_obj = OpenStruct.new(name: "Joe", age: 15)
some_obj.sure = "three"
some_obj.really = "yes, it is true" 
some_obj.not_only_strings = 10
puts "#{some_obj.name} #{some_obj.age} #{some_obj.really}"
#=> Joe 15 yes,it is true

method_missing and Performance:

因为调用是直接的，所以可能会慢一些，但大多数情况下不影响。

如果考虑响应速度的话，可以考虑hybird approach 

*Define a real method from inside method missing after an attempted ‘call’

 

Ghost methods allow you to call methods as if they are there even though they are not
Method behavior can be defined at runtime , for example based on database columns existing or not .