ruby的class << self, 及其class_eval和instance_eval的区别

ruby的class << self, 及其class_eval和instance_eval的区别

昨天在看web敏捷开发之道的时候看到class << self这样的语法，一下子弄蒙了，丫的这是什么语法阿。呆了，完全看不懂。后来经查google才知道是单态方法——singleton_method

关于class << self,有一篇比较好的博文，请见：http://www.devalot.com/articles/2008/09/ruby-singleton

定义singleton_methods有三种方式

第一种： 直接给对象打开定义

这是最简单相信也是见得最多的一种方式:

[ruby]   view plain  copy

1. a = Array.new  
2.   
3. def a.size  
4.   "Hello World!"  
5. end  

输入puts  a.size  ====>输出"Hello,World",而不是0

我们知道ruby比较有特点的一个地方是，在任何时间任何地点，可以对一个类或对象打开进行添加方法或者重写方法。

但这是为什么呢？不知道读者有没有想过这个问题。从静态语言的角度，比如java或者C＋＋，我么知道只能在一个类的范围内添加方法。学过汇编的朋友知道，方法本身是内存中的一段指令而已。只不过把一些传参或者返回之放在指定的寄存器上。而ruby底层是用C写的。C++和java中的类本质跟C中的结构体也没有什么区别，术语多态和回调只不过是在指定的方法表(每个java类字节码都有一个方法表）入口处放置实际C的函数指针。

经过上面的分析，是不是意味着ruby类的开放性也是基于类的呢？

查过google之后，发觉分析对了。原来ruby在任何地方能对一个既存的对象打开也是基于类的，只不过是个匿名的内部类而已，而这个类继承于当前实例的类。

所以，在上面的代码中，我们完全可以调用super方法调用父类的相应函数。如

[ruby]   view plain  copy

1. a = Array.new  
2.   
3. def a.size  
4.   puts super  
5.  "Hello World!"  
6. end  

puts a.size ======> 输出

0

"Hello,World"

说明我们理解没有偏差。

这样，我们对于第二种方式也就不难理解了。

第二种：使用"<<"方式

上面的代码还可以这样写:

[ruby]   view plain  copy

1. a = Array.new  
2.   
3.   
4. class << a  
5.   def size  
6.     puts super  
7.     "Hello,World"  
8.   end  
9. end  
10.   
11. puts a.size =======>   
12. 0  
13. "Hello,World"  
14.   
15. b = Array.new  
16. puts b.size =========>  
17. 0  

很显然，第二种方式比较能体现本质（某一个类继承于a，然后重写size这个方法）

第三种方式，通过instance_eval

[ruby]   view plain  copy

1. a = Array.new  
2.   
3. a.instance_eval <<EOF  
4.   def size  
5.     puts super  
6.     puts "Hello,World!"  
7.   end  
8. EOF  
9.   
10. <strong>b = Array.new  
11.   
12.   
13. a.size =======>   
14.   
15. 0  
16.   
17. "Hello,World"  
18.   
19. b.size ====>  
20.   
21. 0</strong>   

虽然明白instance_eval是singleton_method方式的一种，但是因为是第一次见instance_eval,于是google之，发现原来这玩意儿和class_eval很相似。于是又google class_eval.

于是，又发现一篇比较好的博文：http://www.jimmycuadra.com/posts/metaprogramming-ruby-class-eval-and-instance-eval

博文中说道，class_module是从Module中得到的，所以class_module的接受者必须是个类，比如说

[ruby]   view plain  copy

1. a=Array.new  
2. a.class_eval 这样是错的，会报找不到class_eval这个方法  
3.   
4. 应该是Array.class_eval才可以  

而我们知道在混合编程(mix)中，include 某个Module时，该Module的所有实例方法只能由子类的实例所调用（相当于多了继承于Module），故class_eval定义之后，只能是Array的所有的实例调用，Array自己调用会出错（肯定的，假如Array自己调用不出错的话，这个方法就是静态方法了）

[ruby]   view plain  copy

1. a=Array.new  
2.   
3. Array.class_eval do  
4.   def hint  
5.     "hello"  
6.   end  
7. end  
8.   
9. puts a,hint  输出hello  
10. b = Array.new  
11. puts b.hint  输出hello  
12.   
13. puts A.hint 出错，没有找到这个方法  

ruby是完全面向对象的，即使对于某个实际的类也是如此。ruby的任何类，比如Array，或者是任何自己定义的类，都是Class类的实例。所以，类的静态方法，相当于这个类（或者是Class类的对象）的singleton_methods.也就是说，ruby本质是没有静态方法的。

基于此，也就很自然的明白instance_eval了。

比如，我像下面这样定义

[ruby]   view plain  copy

1. a=Array.new  
2. a.instance_eval do  
3.   def hint  
4.    "hello"  
5.   end  
6. end  
7.   
8. puts a.hint  输出hello  
9. b=Array.new  
10. puts b.hint  报错，没有找到此方法  
11.   
12. 假如我像下面这样定义:  
13. Array.instance_eval do  
14.   def hint  
15.    "hello"  
16.   end  
17. end  
18.   
19. 本质上相当于这样的代码:  
20. class Array  
21.   def self.hint  
22.     "hello"  
23.   end  
24. end  
25.   
26. 当然,也可以是这样  
27. class Array  
28.   class << self  
29.     def hint  
30.       "hello"  
31.     end  
32.   end  
33. end  
34.   
35. <strong><span style="color:#660000;">不过ruby对静态代码的限制比较强，不像java，实例可以调用静态方法，在ruby中，静态方法只能是类调用，因为ruby本质是没有静态方法的，只有实例方法。只有所属的对象才能调用自己的  
36. 方法，这也间接地说明了ruby是一种完全的面向对象语言。</span></strong>