但行好事 莫问前程

1 动态的evaluate代码

全局的方法eval 编译并且执行一段包含ruby代码片断的字符串，这是一个很power的机制，因为它允许你建造在运行时

执行的代码。看下面的例子：

parameters = {}

ARGF.each do |line|
  name, expr = line.split(/\s*=\s*/, 2)
  parameters[name] = eval expr
end

假设输出是这样的：



然后你的parameters 应该是这样的{"a"=>1, "b"=>5, "c"=>"Mon Apr 30 21:17:47 CDT 2001\n"}. 不过这样的话，危

险性很高，假设你传入一个 "rm *"那么就很郁闷了。

ruby有三个方法来做到在运行时evaluate代码，class_eval, module_eval, 和instance_eval，前两个是同义的，而这三

个方法其实所做的事都是一样的，他们都是evaluate 一个字符串，或者一个block，但是在做这件事的时候，他们会把

self改变为他们自己的接收者.如果你想看一些例子，推荐你去看ruby的内置库delegate.rb.

eval 方法还能够在局部变量的创建域外面调用evaluate.

你能够使用 Kernel#binding方法来将一个当前的绑定付给一个对象。而eval的第二个参数就是这个绑定：

def some_ethod
  a = "local variable"
  return binding
end

the_binding = some_method
eval "a", the_binding   # "local variable"

而如果带有block的话，这个block则是被存储为这个绑定的一部分：

def some_method
  return binding
end

the_binding = some_method { puts "hello" }
eval "yield", the_binding                # hello

2 使用const_get


const_get方法从类或者模块得到一个常量的值：

str = "PI"
Math.const_get(str)     # Evaluates to Math::PI

这是一种避免使用eval的方法。还有一些类似的方法instance_variable_set, instance_variable_get和

define_method.

const_get 比eval快，而且他更可读，更明确。

3 通过一个名字来动态的实例化一个类

可以使用const_get方法。在ruby中的所有类通常情况下都被命名为一个常量作为Object的一个全局成员.

classname = "Array"

klass = Object.const_get(classname)
x = klass.new(4, 1)        # [1, 1, 1, 1]

如果类名字嵌套的话，就会报错：

class Alpha
  class Beta
    class Gamma
      FOOBAR = 237
    end
  end
end

str = "Alpha::Beta::Gamma::FOOBAR"
val = Object.const_get(str)          # error!

这是因为const_get方法并没有那么智能，可是我们可以这么做：

str = "Alpha::Beta::Gamma::FOOBAR"
val = str.split("::").inject(Object) {|x,y| x.const_get(y) }  # 237

4 动态的存取实例变量

看下面的例子：

class MyClass
  attr_reader :alpha, :beta

  def initialize(a,b,g)
    @alpha, @beta, @gamma = a, b, g
  end
end


x = MyClass.new(10,11,12)

x.instance_variable_set("@alpha",234)
p x.alpha                                   # 234

x.instance_variable_set("@gamma",345)       # 345
v = x.instance_variable_get("@gamma")       # 345

这里要注意的是，必须用变量的全名来作为参数，也就是说要带上@符号.

5 使用define_method

比起def,define_method只是一个很平常的加一个方法到一个对象或者一个类的一个方法.

如果我们想要在一个方法体内，或者其他类似的地方，重新打开这个类(也就是说增加一些方法)，那么除非这个类是singleton class。这时，在老版本的ruby中我们必须使用eval，可是现在我们能够使用define_method。由于define_method是private的，所以我们必须这样使用：

if today =~ /Saturday|Sunday/
  Object.class_eval { define_method(:activity)  { puts "Playing!" } }
else
  Object.class_eval { define_method(:activity)  { puts "Working!" } }
end

activity

我们也可以把define_method直接插在一个类里面：

class MyClass
  define_method(:mymeth) { puts "This is my method." }
end

然后你可以这样做：

class MyClass
  def self.new_method(name, &block)
    define_method(name, &block)
  end
end

MyClass.new_method(:mymeth) { puts "This is my method." }
x = MyClass.new
x.mymeth           # Prints "This is my method."

如果你想要使用在实例级别，你可以这么做：

class MyClass
  def new_method(name, &block)
    self.class.send(:define_method,name, &block)
  end
end

x = MyClass.new
x.new_method(:mymeth) { puts "This is my method." }
x.mymeth           # Prints "This is my method."

这里要注意，之所以使用send，是因为send也可以用于私有方法，而在ruby1.9中，send是不能用于私有方法的.


我们可以看到define_method方法还带有一个block为参数，这就意味着，我们能够保留定义这个block时的上下文：

class MyClass
  def self.new_method(name, &block)
    define_method(name, &block)
  end
end

a,b = 3,79

MyClass.new_method(:compute) { a*b }
x = MyClass.new
puts x.compute           # 237

a,b = 23,24
puts x.compute           # 552

看下面的我们读取一个类变量的例子：

class SomeClass
  @@var = 999

  define_method(:peek) { @@var }
end

x = SomeClass.new
p x.peek             # 999

假设这时我们想要读取一个实例变量：

class SomeClass
  @var = 999

  define_method(:peek) { @var }
end

x = SomeClass.new
p x.peek             # prints nil

竟然打印出nil。为什么呢？可是修改一下又可以打出正确的值了：

class SomeClass
  @var = 999
  x = @var

  define_method(:peek) { x }
end

x = SomeClass.new
p x.peek      # 999

原因是，新建的方法的上下文是对象实例的上下文，而不是类的。因此，在这里的这个类实例变量会被对象的实例变量

所覆盖，也就是说这里打印的其实是实例变量@var。

6 使用const_missing

const_missing 方法和method_missing很相似，如果你想要得到一个你不知道的常量，这个方法就会被调用：

class Module
  def const_missing(x)
    "from Module"
  end
end

class X
end

p X::BAR        # "from Module"
p BAR           # "from Module"
p Array::BAR    # "from Module"

如果想要让他作为一个类方法，你可以这样做：

class Alpha
  def self.const_missing(sym)
    "Alpha has no #{sym}"
  end
end

class Beta
  def self.const_missing(sym)
    "Beta has no #{sym}"
  end
end

class A < Alpha
end

class B < Beta
end

p Alpha::FOO       # "Alpha has no FOO"
p Beta::FOO        # "Beta has no FOO"
p A::FOO           # "Alpha has no FOO"
p B::FOO           # "Beta has no FOO"

7 移除定义

比如一个方法，我们想要彻底的删除它，这时我们就能用到undef(和def刚好相反).你能够undef 方法，局部变量，常量...可以要注意你不能undef一个类:

def asbestos
  puts "Now fireproof"
end

tax = 0.08

PI = 3

asbestos
puts "PI=#{PI}, tax=#{tax}"

undef asbestos
undef tax
undef PI

# 下面调用上面的方法或者变量就会报错

这里要注意，你不能undef一个实例变量.

还有remove_method 和 undef_method方法，他们的不同是很细小的：remove_method 将会remove掉当前的方法定义。 undef_method 方法 将会remove掉所有的方法定义(比如超类的方法）：

class Parent

  def alpha
    puts "parent alpha"
  end

  def beta
    puts "parent beta"
  end
end

class Child < Parent

  def alpha
    puts "child alpha"
  end

  def beta
    puts "child beta"
  end

  remove_method :alpha   # Remove "this" alpha
  undef_method :beta     # Remove every beta

end


x = Child.new

x.alpha          # parent alpha
x.beta           # Error!

remove_const 将会remove掉一个常量.

module Math

  remove_const :PI

end

# No PI anymore!

我们现在可以利用remove_const，来移除掉一个类的定义(因为类的标识符其实也就是一个常量)：

class BriefCandle
  def test
    p "aaa"
  end
end

out_out = BriefCandle.new

class Object
  remove_const :BriefCandle
end
out=BriefCandle.new
out_out.test

要注意remove_const和remove_method都是私有方法.