Ruby元编程-Week-1

更多文章欢迎来沈小黑的菜园转转啦啦啦~~

转入魔都

啊哈~自从不做阿里实习生之后,在学校浑浑噩噩过了一周左右,终于又开始找实习~先投了猿题库,无奈要等到十月中旬才能面试,就先面了eBay,没想到还挺顺利地就过了,就这么当着杭州的二房东跑到上海开始实习生涯了~~
P.S. 6号拿到offer13号入职,到现在才写下这段话的效率也是堪忧啊~

初遇Ruby

说是Ruby元编程,是打算写下读《Ruby元编程》的一些笔记,但是在这之前,还是要先讲讲怎么会开始学习Ruby了呢~

10月13日,那是一个风和日丽的早晨。来到eBay之前就风闻是个很闲适的公司,闲适到七爷得知我到eBay实习后的第一回应就是“哦!很清闲!”。当主管和我聊到需要做的事情的时候,才知道需要使用Ruby开发,说实话心里还有点小激动“早听说Ruby很厉害,我要成为那个不拘一格的一员了么~”。其实一般都会有这样的心态:使用越小众的语言就显得越厉害…当然残存的理智告诉我,程序员是不可能因为换个语言而变厉害的,更何况一个连Java都谈不上精通的程序员。

学之前还是挺忐忑的,但是我那慵懒的,十二点左右上班,六点左右下班的mentor跟我说“这玩意儿很简单的,你随便看看就会了”。于是我收拾心情,花了一个晚上看了一下Ruby语法,诶~感觉跟python还蛮像的,可能还真的很简单呢!

就这样,我要开始我的Ruby学习之旅了~!
上面这样的句式总是会让人感觉你现在已经是某某的大师,其实我现在还什么都不懂哈哈!

Ruby元编程

好了,终于开始正篇。

其实一个语言的语法很简单,有一本书大致叫《七天学习七门语言》,讲的就是七天内掌握七门语言的语法,这对于熟悉一门编程语言的人来说其实并不难。但语言的精髓其实在于它的设计思想,当真正领会了一门语言的设计思想之后,我想以后学习其他语言的时候,不仅能很快掌握语法,更能迅速地利用这门语言的特性写出优秀的代码吧。所以在看了“Ruby菜鸟教程”这种语法科普之后,我就开始看《Ruby元编程》啦,因为是松本行弘本人写的,看网上的评价也非常好,所以…希望能从中一窥Ruby号称的“元编程”到底比起Java等语言神奇在何处。

《Ruby元编程》其实是一个故事…书中主人公跟我一样是一个刚进公司的实习生,和他结对编程兼任mentor的是一个Ruby大师~然后他们的故事以一天为一章…其实书很薄,当然也要看有没有足够的时间,所以~就按照章节来写笔记吧。

今天是“星期一”。

内省

在很多语言,比如C++中,语言构件(变量、类、方法等)在编译器完成工作之后,就变成了看不见摸不着的东西,只是内存位置而已。

而在Ruby和其他很多语言中,运行时绝大多数的语言构件依然存在。可以从构件处获得关于它自己的信息。这称为内省。

内省的例子:

class Greeting 
    def initialize(text) 
        @text = text 
    end  

    def welcome 
        @text 
    end
end 

my_obj = Greeting.new("Hello")


puts my_obj.class ,my_obj.class.instance_methods(false) ,my_obj.instance_variables

通过这样的代码,就可以获得关于对象本身的很多信息。这样说来,Java也是内省的语言。

C在运行时中,只有一大堆机器码。在C++中,一些语言构件可以在编译后留下来。Java中,编译时和运行时界限十分模糊,可以有足够的内省能力来列出一个类的方法和继承关系等。

最彻底的是Ruby,Ruby中没有编译时的概念,所有的构件都在运行时可用。

元编程

比起内省,元编程更进一步,它允许对语言构件进行修改,举个例子:

在Java中, 假如想要写一个DBModel,必须要把数据库中的字段都一一对应写在类中,并添加getter和setter。而在数据库字段发生改变的时候,还必须相应地改变类的实例变量和对应的实例方法。而在Ruby中,只要写出如下的代码,就可以自动完成数据表的映射:

class Movie < ActiveRecord::Base
end

这样就能直接使用Movie#title()来访问title字段。这些方法和变量都没有定义过,那么ActiveRecorder是怎么实现的呢?

因为类名是Movie,ActiveRecord会把它映射到名为movies的表中。而那些访问属性的方法,是ActiveRecord从表模式中得到字段名后,自动定义的方法。

写入语言构件的能力就在这时候发挥作用了,至于这种能力是怎么实现的,在后面的书中会进行讲解。

元编程是编写在运行时操纵语言构件的代码。

这就是元编程的概念~

Open Class特性

Open Class特性
在Ruby中,第二次定义一个类只会修改已经存在的类,比如:

class D
    def x
    end
end

class D
    def y
    end
end

这样的话,D就有x和y两个方法了。

值得注意的是…这样很可能导致原来其他地方使用的方法被重写,从而导致运行出现问题。这是Open Class的隐患,经常被称作猴子补丁 Monkeypatch

为了避免猴子补丁的问题,我们可以将类放在模块中,这样就能很大程度上避免命名冲突了。(还是有可能会发生问题:只要两处的模块名相同且类名相同,就依然会有猴子补丁的问题)

另外还有其他的解决方案,选择子空间等等…当然,书中的mentor说在书后面会讲到,那就后面看到再说吧~

Ruby类的真相

在Ruby这样的动态语言中,对象的类和实例变量没有关系,当给实例变量赋值时,它们就生成了。如下例,输出是如果不曾调用my_method,那么输出的变量列表就是空

class MyClass 
    def my_method 
        @v=1 
    end
end 

obj = MyClass.new  
puts obj.instance_variables

实例变量存放在对象中,而方法(包括类方法和对象的方法)放在类中。

类自身也是对象。类自身的类叫做Class.
在这里类是一个对象,那么这个对象的类:Class也就拥有了这个对象的实例方法。所以一个类的方法就是Class的实例方法。

Class的superclass是Module
Module的superclass时Object
Object的superclass是BasicObject……MyClass
BasicObject的superclass是nil

因此,Class只不过是在Module的基础上增加了new、allocate和superclass这三个方法的增强模块罢了。

可是运行Module.methods可以找到这三个方法?

首先,methods,private_methods是Object类的实例方法;instance_methods是Module类的实例方法。
Ruby对象可以分为2类,一类是普通对象,还有一类对象是类(类本身也是一种对象),像String,Class这种类,这种对象叫类对象。
普通对象的祖先链,以”abc”为例,为String-> Comparable->Object->Kernel-> BasicObject
类对象的祖先链,以String为例,为Class->Module->Object->Kernel-> BasicObject
我们可以看到普通对象是没有instance_methods方法的,因为其祖先链上没有Module类。所以对于一个普通对象,我们只能说它有方法或私用方法,而不能说它有实例方法,实例方法是对一个类来说的。
(引用自slef-motivation的博客http://blog.csdn.net/happyanger6/article/details/42436879)

所以运行Module.methods找到的是Object类中的方法,那时候自然会有这三个方法。在Module.instance_methods中就找不到这三个方法了。

Module类提供了两个constants()方法,实例方法Module#constants()返回当前范围内的常量,而类方法Module.constants()返回当前程序中所有的顶级常量,包括类名。

module MyClass   AAA = 'aaa'   def my_method  @v=1  end end  
MyClass.constsants #返回AAA
Module.constants    #返回Object,Module,Class,BasicObject......MyClass。这些都是顶级常量(类名也是顶级常量),而AAA由于不是顶级的常量,所以没有被列在里面

当在一个类中包含一个模块时,Ruby创建了一个封装该模块的匿名类,并把这个匿名类插入到祖先链中。

module M  
    def my_method   
    end 
end  

class C  
    include M 
end  

puts C.ancestors

结果输出:

C
M
Object
Kernel
BasicObject

祖先链会包含模块,在这里是M和Kernel

那么Kernel模块又是什么呢?

Ruby中有像print()这类方法,我们可以在任何代码空间中调用它们,这实际上都是Kernel模块的私有方法。Object类包含了Kernel模块,而Object类是任何类的superclass,所以任何类都会包含Kernel模块,也就有了Kernel内的私有方法。

self

由于对象和类的方法分开,对象必须要有一个self引用才能让方法知道当前调用者是谁。

通常self是最后一个接收到方法调用的对象,但是当在类和模块中定义时,self的角色由类/模块担任。

class MyClass
    self                    # => MyClass
end

所以在类中定义方法前加上self就是类方法/单例方法了,因为这时self是类自己

class MyClass
  def self.claz_method
    p 'this is a class method'
  end

end

MyClass.claz_method

puts MyClass.singleton_methods(false)  # => claz_method

Ruby中特殊的private规则

Ruby中不允许明确指定一个接收者来调用一个私有的方法。换言之,每次调用一个私有方法时,只能调用于隐含的接收者——self上。

class C  
    def public_method  
        self.private_method 
    end   

    private  
    def private_method   
    end 
end   

C.new.public_method

就算这样,指定self,依然会调用失败,因为要求只能调用于隐含的self。

关于self的一个案例

module Printable  
    def print
      puts 'print in Printable'
    end 
end  

module Document
  def print_to_screen
    print 
  end   

  def print  
    puts 'print in document'  
  end 
end  

class Book  
    include Document  
    include Printable 
end   

Book.new.print_to_screen

这里的输出结果是”print in Printable”

因为祖先链是:[Book, Printable, Document, Object , Kernel, BasicObject]

所以self在print_to_screen中寻找print方法时,由于self所属的Book类没有print方法,所以向从Book类向上寻找,而到Printable就已经找到方法了,就会调用Printable中的print方法。

总结

这就是今天的《Ruby元编程》抄写情况,谢谢观看~

你可能感兴趣的:(读书笔记,编程语言)