Aiur

zellux 的博客

《Metaprogramming Ruby》笔记

Permalink

Ruby 元编程

一、Ruby 对象模型

1
2
class MyClass; end
obj1 = MyClass.new

这段代码中 obj1 和 MyClass 都是引用,唯一的区别在于前者是一个变量,后者是一个常量。

Ruby 对象由两部分组成:实例变量和指向类的引用。

在类中包含一个模块时,Ruby 会在继承链中插入一个匿名类,这个匿名类包含了该模块所有方法:

1
2
3
class A; include Math; end

A.ancestors # => [A, Math, Object, Kernel, BasicObject]

正因为这种机制,puts 方法才可以在一个普通类中使用。因为 Object 包含了 Kernel 模块,所以 Kernel 模块的方法会包含在每一个普通类的继承链中,其中包括了 puts 方法,当你在其他类中调用 puts 方法输出时,其实是调用了 Kernel 的 puts 方法。

Ruby 中私有方法的限制很简单,即不能为私有方法指定一个显式的接收者(例如 abc.method 中 abc 就是显式的接收者) 。也就是说,私有方法只能只能在隐式的接收者(即 self)上调用。

二、方法

动态定义方法

Blank Slate

某些情况下需要覆盖类中已经存在的方法(如 jbuilder )。使用 undef_method 可以取消类中已经存在的函数,但仍需保留 instance_eval 以及 __开头的方法。这种特殊的状态被称为 Blank Slate。

blankslate 提供了一个现成的 Blank Slate 基类。此外 Ruby 1.9 中 BasicObject 也有类似的作用。

三、Block

Scope Gate

Scope Gate 指程序中创建新的作用域的地方,Ruby 中 class module 和 def 三个关键字有 Scope Gate 的作用。

如果要在定义类/方法的同时避免产生新的作用域,可以用 Class.new() 和 Module#define_method() 代替 class 和 def。这种技巧被称为 nested lexical scope,也有人称它为 flat scope。

& 符号

& 符号的作用是使 Proc 和 block 相互转换,例如:

1
2
3
4
5
6
7
def my_method(&the_proc)
  the_proc
end

p = my_method { |name| "Hello, #{name}!" }
puts p.class # => Proc
puts p.call('Bill') # => Hello, Bill!

Block、Proc、Lambda 和 Method

  • Block 并不是真正的对象,虽然它们也可以被调用。Block 在定义的上下文中执行。

  • Proc 是实际的对象,也在定义的上下文中执行。

  • Lambda 对象和 Proc 对象有一些细微的差别(return 的行为和参数的检查上,Lambda 更像 Method),在定义的上下文中执行。
  • Method 被绑定在某个对象上,在该对象的作用域中执行。

四、类定义

self

类定义中的 self 指向当前类本身:

1
2
3
4
5
result = class MyClass
  self
end

result # => MyClass

类变量

在类定义中以 @@ 前缀开始的变量就是类变量,与类的实例变量不同的是,他们可以被子类和实例方法访问到。类变量同时属于所有的子类,任何一个子类对它的修改都会对父类起作用,这会导致一些难以发现的问题。因此现在更推荐用类的实例变量代替类变量。

eigenclass

Ruby 中每一个对象都有一个属于自己的隐藏的类,这个类就被称为 eigenclass。使用 class << obj 语法可以访问该对象的 eigenclass。

1
2
3
4
5
6
obj = Object.new
eigenclass = class << obj
  self
end

eigenclass => #<Class:#<Object:0x000001022097b8>>

事实上 instance_eval 也会修改类对象,只是它修改的是接收者的 eigenclass。

extend 方法可以把一个模块中的方法添加到接收者的 eigenclass 中。

Ruby 对象模型

以下七条规则描述了 Ruby 的对象模型:

  1. 对象只有一种,不管是标准类还是模块;
  2. 模块只有一种,不管是标准的模块,类,eigenclass,或是代理类;
  3. 方法只有一种,而且只存在于某一模块中——大多数情况下是在一个类中;
  4. 每一个对象,包括类,都有自己的实际的类,无论是标准类还是 eigenclass;
  5. 每一个类都只有一个父类(BasicObject 除外)。因此每个对象都有一条单一的直到 BasicObject 的继承链;
  6. 一个对象的 eigenclass 的父类是这个对象的类。一个类的 eigenclass 父类是这个类的父类的 eigenclass。听起来很绕口,但这句话是 Ruby 对象模型的核心之一,参考这篇文章的最后的一幅图可以帮助理解;
  7. 当方法被调用时,解释器首先在接收者的 eigenclass 中查找该方法,如果找不到,则沿着继承链一路网上找。

方法重命名

当一个方法被重定义时,它本身没有被修改,只是原来的名字绑定了一个新方法。因此只要有指向原来的方法的引用,该方法仍然能被调用到。

RubyGems 库就是这么处理 require 的,新定义的 require 方法先调用原来的 require,如果发生异常,则在 gems 库中再查找一次需要的包,找到了就调用原来的 require 把这个包加载进来。具体可以看 custom_require.rb

五、编写代码的代码

Binding 对象

在 Ruby 中可以把整个作用域打包成一个 Binding 对象,配合 eval() 相关的一系列方法可以在这些作用域中执行代码。

Taint Tracking

Ruby 里也有类似 taint tracking 的机制,来自外部的输入会被加上 tainted 标记,用 tainted? 方法可以查看某个实例是否来自不可信的内容。

为了保证 eval() 方法安全性,Ruby 中还有一个名为 $SAFE 的全局变量控制 eval 的安全级别。当它为 0 时不做任何安全检查;当它为 4 时安全级别最高,程序甚至无法随意地退出。

Hooks

Class#inhertied()Module#included()Module#method_added() 等都是 Ruby 提供的 hook 方法。它们会分别在类被继承、模块被引用和方法被添加时执行。

Rails 元编程

下半部分主要结合 Rails 2.3 的源代码,分析了 Rails 中用到的和 Ruby 元编程相关的特性:

评论