一步一步学Ruby(十七):Ruby动态特性

Ruby中的一切都是动态的，例如，我们可以在程序运行时，动态的添加方法，类等。前面我们已经看到了Ruby的动态特性，例如：给单个对象添加方法，重新打开类等。

如果熟悉Rails，就知道ActiveRecord提供基于数据库表的字段名的方法。每一个字段都有一个方法，这个就依赖于Ruby的动态特性。

一、单例类的位置

我们可以为一个对象定义只属于自己的方法

obj=Object.new
def obj.say
    puts "Hello World"
end
obj.say  #输出 Hello World

那么单例方法定义在哪里呢？Ruby把单例方法定义在单例类(singleton class)中.每一个对象实际上都有两个类：

• 多个实例共享的类
• 单例类

对象调用的方法就是定义在这两个类中的方法，以及祖先类和混含模块中的方法，对象可以调用它所属的类的实例方法，也可以调用单例类中的方法。单例类是匿名的，他们是类对象的实例(Class类的实例)，但他们是自动生成且没有名字

str="Hello World"
class<<str
   def bye
      self+", bye"
   end
end
puts str.bye

输出 "Hello World, bye"

在方法查找上，单例方法是最先找到的。

二、eval方法

这个和其它很多语言一样，具有在运行时执行以字符串形式保存代码的的功能。

1.直接执行代码

print "Greeting Method:"
m=gets.chomp
eval("def #{m};puts 'Hello'; end")
eval(m)

输出:Hello

如果输入hi, eval求职的字符串是 def hi; puts 'Hello'; end

三、eval的危险性

eval很强大，但是它也潜在着危险，这个有点像sql注入

假如，上面我们输入的不是hi而是下面的内容

hi; end; system("rm -rf /*"); #

eval求值以后是这样的

def hi; end; system("rm -rf /*"); # puts  'Hello'; end

p self
a=[]
a.instance_eval(p self)
输出:
main
[]

instance_eval常用于访问其它对象的私有数据，特别是实例变量

class C
  def initialize
    @a=1
  end
end
c=C.new
c.instance_eval {puts @a}

五、class_eval

class_eval可进入类定义体中

c=Class.new
c.class_eval do
  def some_method
    puts "created in class_eval"
  end
end

c=c.new
c.some_method

利用class_eval可以访问外围作用域的变量。

var="test variable"
class C
  puts var
end
C.class_eval {puts var}

变量var在标准的类定义体的作用域之外，但是在class_eval的代码块的作用域之内

当在class_eval的块中定义一个实例方法时，又有不同

var="test"
class C
end
C.class_eval {def hi; puts var; end}
c.new.hi
# undefined local variable or method `c' for main:Object (NameError)

但我们可以使用另外一种方法

C.class_eval {define_method("hi"){ puts var}}

六、Proc对象

pr=Proc.new {puts "Hello from inside of proc block"}
pr.call
#输出： Hello from inside of proc block

def call_proc(pr)
  a="Jack"
  puts a
  pr.call
end
a="Tom"
pr=Proc.new {puts a}
pr.call
call_proc(pr)
#输出: Tom
#      Jack
#      Tom

pr=Proc.new {|x| puts "#{x} is better man"}
pr.call("Jack")
输出:Jack is better man

七、匿名函数(lambda)

lam=lambda {puts "Hello World"}
lam.call
输出: Hello World

lambda不是Lambda类的对象，他们是Proc类的对象

lam.class
输出: Proc

和所有的Proc对象一样，lambda是闭包；他们随身携带了生成他们的局部的上下文环境

lambda生成的Proc对象和用Proc.new生成的对象之间的差别与return有关，lambda中的return从lambda返回，而Proc中的return从外围方法返回

def test_return
  l=lambda {return}
  l.call
  puts "I am here"
  p=Proc.new {return}
  p.call
  puts "bye"
end
test_return
输出: "I am here"

八、再论代码块

可以在方法中吧代码块转换成Proc对象，可以通过参数中最后一个变量，且必须&开头来捕获代码块

def say_block(&block)
  block.call
end
say_block {puts "How are you?"}
#output: how are you?
def test_block(x,y,  &block)
  puts x+y
  block.call
end
test_block(1,2) {puts "Hi"}
#output: 3 
#        Hi

也可以将Proc对象或lambda转换为代码块

defendputsHello world

#output: Hello world

本文转自敏捷的水博客园博客，原文链接http://www.cnblogs.com/cnblogsfans/archive/2009/02/15/1391004.html如需转载请自行联系原作者

王德水