【ruby】ruby 动态方法总结

本文对ruby动态方法特性进行探讨。

结合以下例子：

 

Ruby代码  

1. #dynamic methods  
2. class Dynamic  
3.    def a  
4.      puts "this is method a"  
5.    end  
6.    def b(bob)  
7.      puts "this is method b:#{bob}"  
8.    end  
9.    def c  
10.      puts "this is method c"  
11.    end  
12.    def self.define_component(name)  
13.      define_method(name) do  
14.         puts "my name is #{name}"  
15.         end  
16.    end  
17.     
18.    define_component :computer  
19.    define_component :car  
20.     
21.    def method_missing(name,*args)  
22.      methodname=name.to_s  
23.      super if !%w[andy sky fly].include? methodname  
24.      puts "mehtod name is:#{name}.  args:#{args}"  
25.    end  
26.     
27.    end  
28.   
29. d=Dynamic.new  
30. d.a  
31. d.send(:b,"bob")  
32. d.send("c")  
33. d.car()  
34. d.computer()  
35. d.fly("in the sky")  
36. d.bob()  

 运行结果：

 

解释：

1.send方法

Ruby代码  

1. d.send(:b,"bob")  #调用对象d的方法b，参数是“bob”  
2. d.send("c")  #调用对象d的方法c。  

 

send可以理解为向对象传递一个消息，消息是调用方法。是直接调用方法的另外一种方式。

优势是方法名字可以作为变量的方式传递进来，增加了很大的灵活性，如基于这个可以把方法调用组合定义到配置文件，根据配置文件里的定义调用方法。机制有点类似java的反射。

2.define_method方法

define_method提供了一个强大的功能，定义方法。可以认为是元编程，编写代码的代码。假设有很多类似的方法，方法的结构基本是一样的，只是名字或参数不一样，这时候定义这样多个的方法就可以通过define_method来动态生成。

Ruby代码  

1. d.car() #调用方法car  
2. d.computer()#调用方法computer  

虽然类Dynamic没显式定义car和computer方法，但是能调用者两个方法是因为通过define_method元编程定义了这个两个方法。如下：

##定义了一个类方法，方法的功能就是根据入参，定义方法  

Ruby代码  

1. def self.define_component(name)  
2.     define_method(name) do  
3.        puts "my name is #{name}"  
4.        end  
5.   end  
6.   
7.   define_component :computer  #定义方法computer  
8.   define_component :car        #定义方法car  

 

3.幽灵方法和method_missing方法

幽灵方法：一个在类中没有定义的方法，但是可以运行。

method_missing:ruby定义里，如果层层都找不到方法定义，就会调用这个方法。每个类默认都继承了method_missing,且默认的实现是打印NoSushMethodErro消息。这个机制使得幽灵方法得以实现。

以上例子：

d.fly("in the sky")能够调用通过 而d.bob()不能调用通过，正式因为Dynamic类的method_missing是这样定义的：

Ruby代码  

1. def method_missing(name,*args)  
2.   methodname=name.to_s  
3.   super if !%w[andy sky fly].include? methodname   ###如果方法名不在 and sky fly里面就调用继承父方法，在这里的才继续执行。  
4.   puts "mehtod name is:#{name}.  args:#{args}"  
5. end  

 

总结：

从动态方法的这个几个特性来看，ruby 方法定义确实是非常灵活的，也是动态语言的一大特性和优势。而在java这种静态语言里似乎很难有这种灵活性。

静态使得方法很规范，且不容易犯错(在编译期就会检查出很多错误，不会带到运行期)

动态增加了很大的灵活性，但也可能带来不规范，容易犯错，错误不好定位等问题。

各有优势，适用不同场景。

转自：http://singleant.iteye.com/blog/1680382