一步一步学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

本文作者：王德水