一步一步学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.直接执行代码

2. 运行时提供方法名的例子

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

求值的结果是：#后面的所有内容会被作为注释忽略掉。使用system命令试图删除系统所有文件

Ruby有一个全局变量$SAFE(取值范围是0到4)、以获取对如非法写文件这一类危险的防护。

四、instance_eval

该方法把self变为instance_eval调用的接收者，对字符串或代码块进行求职

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

1、做为闭包的Proc对象

Proc对象随身携带了它的上下文，下面上下文包含一个变量a，该变量被赋值为一个特殊的字符串保存在Proc对象中。像这样带着产生它的上下文信息的

一段代码被称为闭包。产生一个闭包就像是打包一件行李：任何时候打开行李，都包含打包进去的东西，在打开一个闭包时（通过调用它），它包含产生

它的时候你放进去的东西。

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

2. Proc对象的参数

产生Proc对象时所提供的代码块可以接收参数

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转换为代码块

def say_block(&block)
  block.call
end

lam=lambda {puts "Hello world"}
say_block(&lam)
#output: Hello world


本文作者：王德水

未经同意，禁止转载