在 Ruby 中对字符串和 block 求解

阅读数:970 2007 年 8 月 24 日 04:23

介绍

对包含代码的字符串和 block 求解,是我最钟爱的 Ruby 特性之一。Ruby 提供了多种不同类型的求解方式;不过我最常用的是下面这些:eval、instance_evalclass_eval

Module.class_eval

使用Module类的class_eval(及其别名 module_eval)方法,可以在一个类的定义或者module定义的上下文中对给定字符串或 block 进行求解。我们常常用class_eval来向类的定义中加入方法,或是包含其他的 module。

klass = Class.new

klass.class_eval do

include ERB::Util

def encoded_hello



htnl_escape "Hello World"

end

end

klass.new.encoded_hello #=> Hello World

不使用class_eval也可以达到上面的效果,但是要牺牲代码的可读性。

klass = Class.new

klass.send :include, ERB::Util

klass.send :define_method, :encoded_hello do

html_escape "Hello World"

end

klass.send :public, :encoded_hello

klass.new.encoded_hello #=> Hello World

Object.instance_eval

使用Objectinstance_eval方法,可以在一个类实例的上下文中对给定字符串或 block 进行求解。这是个功能强大的概念:你可以先在任何上下文中创建一块代码,然后在一个单独的对象实例的上下文中对这块代码进行求解。为了设定代码执行的上下文,self 变量要设置为执行代码时所在的对象实例,以使得代码可以访问对象实例的变量。

class Navigator

def initialize

@page_index = 0

end

def next

@page_index += 1

end

end

navigator = Navigator.new

navigator.next

navigator.next

navigator.instance_eval "@page_index" #=> 2

navigator.instance_eval { @page_index } #=> 2

与使用class_eval的示例类似,实例变量的值可以通过其他的方式获取,不过使用instance_eval是一种非常直观的做法。

Kernel.eval

使用Kerneleval方法可以在当前上下文中对一个字符串求解。可以选择为eval方法制定一个binding对象。如果给定了一个binding对象,求解的过程会在binding对象的上下文中执行。

hello = "hello world"

puts eval("hello") #=> "hello world"

proc = lambda { hello = "goodbye world"; binding }



eval("hello", proc.call) #=> "goodbye world"

扩展 eval 的上下文

第一次使用eval,我用它来创建了attr_init这个类方法。当时我发现我总是在重复下面代码中的模式:

def some_attribute

@some_attribute || = SomeClass.new

end

因此我决定创建一个类方法来封装上面的行为:

class << Object

def attr_init(name, klass)

define_method(name) { eval "@#{name} ||= #{klass}.new" }

end

end

记得当时我觉得这样调用 eval 是非常丑陋的做法,但那会儿我想不出更好的方式来实现这样的效果;因此我把代码贴到了博客中,等待别人的指摘;他们很快就做出了回应,并给出下面的做法。一开始我并没有觉察这样做的好处,但是后来我意识到这个解法是非常出色的:它只需要调用一次 eval 方法,而不是在每次进行方法定义时都去重新调用 eval。

class << Object

def attr_init(name, klass)

eval "define_method(name) { @#{name} ||= #{klass}.new }"

end

end

这样优化的有趣之处在于:它需要求解更多的内容, 以达到提升运行效率的目的。从那时开始,我只在必要的时候才使用 eval,而且我非常注意如何以更有效率的方式来使用 eval。

在不同上下文中使用 instance_eval

在不同上下文中,对 block 或是以字符串形式出现的代码进行求解是很有价值的一种做法,也是设计领域特定语言(Domain Specific Language,DSL)时很常用的一种技术。实际上,在多种上下文环境中进行求解的能力是使用 DSL 的一个关键因素。请看下面的代码:

class SqlGenerator

class << self

def evaluate(&script)

self.new.instance_eval(&script)

end

end

def multiply(arg)



"select #{arg}"

end

def two(arg=nil)



"2#{arg}"

end

def times(arg)



" * #{arg}"

end

end

使用上面的代码,调用SqlGenerator.evaluate方法并给定一个 block 参数,便可以生成一条 SQL 语句:

SqlGenerator.evaluate { multiply two times two }

=> "select 2 * 2"

然而,你还可以在一个 calculator 类的上下文中执行同样的代码来获得结果:

class Calculator

class << self

def evaluate(&script)

self.new.instance_eval(&script)

end

end

def multiply(arg)



eval arg

end

def two(arg=nil)



"2#{arg}"

end

def times(arg)



" * #{arg}"

end

end

执行结果:

Calculator.evaluate { multiply two times two }

=> 4

上述代码展示了如何使用 instance_eval 来指出 block 执行的作用范围。我在前面提到过,instance_eval 方法在接受者的上下文中对字符串或 block 展开求解。例子中的接收者是SqlGenerator的一个实例和Calculator的一个实例。同时要保证使用self.new.instance_eval这样的方式来调用。如果不调用selfnew方法,会将 block 作为类的一部分进行求解,而不是在类的实例中完成。

上述代码同样展示了开始定义 DSL 所需的一些步骤。创建 DSL 是很有挑战性的工作,但同时会带来很多好处。通过 DSL 来表达业务规则,所带来的好处是可以在多种上下文中执行这些业务规则。如上述示例所展示的,通过在不同上下文中执行 DSL,可以从同一个业务规则产生多种不同的行为。当业务规则随着时间推移而改变时,系统中所有引用该业务规则的构成部分都会随之发生变化。而对 Ruby 求解方法的利用,就是成功实现这种效果的关键。

关于赌场中扑克牌桌的示例

Ruby 提供的不同的求解方法,让我们可以很方便的在不同上下文中执行代码。举例来说,假设你为一个赌场工作,分派给你的任务是设计一个系统。当需要开一张新的扑克牌桌,或是需要知道等多久才能开新牌桌时,这个系统负责通知扑克牌室的工作人员。新开牌桌的业务规则,根据牌桌上的赌注大小和等待列表中的人数多少而不同。例如,对于一个赌注不封顶的牌局来说,牌桌边等待的人数多一些也无妨,因为人们更有可能在一手牌中输光他们所有的钱;如果贸然开新的牌桌,由于没有足够的玩家,该牌桌可能很快就要关闭。规则在 DSL 中可能以下面的方式表示:
if the '$5-$10 Limit' list is more than 12 then notify the floor to open

if the $1-$2 No Limit' list is more than 15 then notify the floor to open

if the '$5-$10 Limit' list is more than 8 then notify the brush to announce

if the '$1-$2 No Limit' list is more than 10 then notify the brush to announce

第一个执行 DSL 的上下文被用来通知赌场雇员。代码如下:

class ContextOne < DslContext

bubble :than, :is, :list, :the, :to

def more(value)



'> ' + value.to_s

end

def method_missing(sym, *args)



@stakes = sym

eval "List.size_for(sym) #{args.first}"

end

def floor(value)



__position(value, :floor)

end

def brush(value)



__position(value, :brush)

end

def open



__action(:open)

end

def announce



__action(:announce)

end

def __action(to)

{ :action => to }

end

def __position(value, title)



value[:position] = title

value

end

def notify(value)



[@stakes, value]

end

end

ContextOne通过下面的代码执行。

script = <<-eos   if the '$5-$10 Limit' list is more than 12 then notify the floor to open

if the '$1-$2 No Limit' list is more than 15 then notify the floor to open

if the '$5-$10 Limit' list is more than 8 then notify the brush to announce

if the '$1-$2 No Limit' list is more than 10 then notify the brush to announce eos


class Broadcast

def self.notify(stakes, options)

puts DslContext.sym_to_stakes(stakes)

options.each_pair do |name, value|

puts " #{name} #{value}"

end

end

end

ContextOne.execute(script) do |notification|



Broadcast.notify(*notification)

end

ContextOne继承自 DslContext。DslContext的定义如下。

class DslContext

def self.execute(text)

rules = polish_text(text)

rules.each do |rule|

result = self.new.instance_eval(rule)

yield result if block_given?

end

end

def self.bubble(*methods)



methods.each do |method|

define_method(method) { |args| args }

end

end

def self.polish_text(text)



rules = text.split("\n")

rules.collect do |rule|

rule.gsub!(/'.+'/,extract_stakes(rule))

rule << " end"

end

end

def self.extract_stakes(rule)



stakes = rule.scan(/'.+'/).first

stakes.delete!("'").gsub!(%q{$},'dollar').gsub!('-','dash').gsub!(' ','space')

end

def self.sym_to_stakes(sym)



sym.to_s.gsub!('dollar',%q{$}).gsub!('dash','-').gsub!('space',' ')

end

end<

ContextOnemethod_missing方法中使用了 List 类,List类代码如下。

class List

def self.size_for(stakes)

20

end

end

ContextOne使用 DSL 检查每张牌桌的List大小,并在必要的时候发送通知。当然,这只是演示代码,List对象也只不过是 stub,以验证 ContextOne 和 DslContext 所有的功能都没有问题。这里要重点注意:方法的执行被委托给了instance_eval,这样才能在ContextOne的上下文中对代码进行求解。

同样的脚本,可以在第二个上下文中执行;这个上下文返回当前正在散播的不同类型的赌博游戏。

class ContextTwo < DslContext

bubble :than, :is, :list, :the, :to, :more, :notify, :floor, :open, :brush

def announce



@stakes

end

alias open announce

def method_missing(sym, *args)



@stakes = sym

end

end

正像我们看到的,添加新的上下文是非常方便的。由于DslContext的 execute 方法调用 instance_eval 方法,上面的代码可以如下的方式执行。

ContextTwo.execute(script) do |stakes|

puts ContextTwo.sym_to_stakes(stakes)

end

为了使我们的示例更加完整,我们创建另外一个例子,显示所有接收通知的位置。

class ContextThree < DslContext

bubble :than, :is, :list, :the, :to, :more, :notify, :announce, :open, :open

def announce; end



def open; end

def brush(value)



:brush

end

def floor(value)



:floor

end

def method_missing(sym, *args)



true

end

end

同样的,这个上下文也继承自使用了 instance_eval 的DslContext,因此,只要运行下面的代码来执行即可。

ContextThree.execute(script) do |positions|

puts positions

end

在多个上下文中对 DSL 进行求解的能力,模糊了代码和数据之间的界线。可以对脚本‘代码’进行求解来生成报表(比如关于系统中已联系雇员的报表)。在展示需要多久才会新开扑克牌桌这样的上下文中,也可以对脚本进行求解(比如,业务规则说明需要 15 个人才能新开一张牌桌,系统知道在等待列表中有 10 个人,因此显示“5 more people needed before the game can start”)。使用instance_eval,我们可以在系统需要的任何上下文中,对同样的代码进行求解。

同样具有魔法的 eval

上述代码展示的是:如何在不同的作用范围中,使用instance_eval对 block 进行求解。不过,eval 方法同样可以在不同的上下文中进行求解操作。下面我来展示如何在 block 的作用范围中对 ruby 代码构成的字符串进行求解。

先让我们从一个简单的例子开始,不过让我们先回顾一下如何根据 block 的 binding 使用 eval。我们需要一个能够帮我们创建 block 的类。

class ProcFactory

def create

Proc.new {}

end

end

在示例中,ProcFactory类有一个方法:create;它的功能只是简单地创建并返回了一个 proc 对象。尽管这看起来似乎没什么特别之处,但我们可以在 proc 对象的作用范围中,使用它对任何包含 ruby 代码的字符串进行求解。这样,我们不需要直接引用某个对象,便可以在这个对象的上下文中求解 ruby 代码。

proc = ProcFactory.new.create

eval "self.class", proc.binding #=> ProcFactory

什么时候会用到这样的功能呢?我最近在开发表示 SQL 的 DSL 时用到了它。我开始使用类似下面代码的语法:

Select[:column1, :column2].from[:table1, :table2].where do

equal table1.id, table2.table1_id

end

上述代码被求解时,跟在 from 后面的[]实例方法将所有的表名保存在一个数组中。接下来,当执行where方法时,传递给 where 的 block 会执行。此时,method_missing方法会被调用两次,第一次针对:table1,第二次针对:table2。在method_missing的调用中,对之前提到过的、用[]方法创建的表名数组进行检查,以查看标识符参数(:table1:table2)是否为合法的表名。如果表名在数组中,我们返回一个知道如何应对字段名称的对象;如果表名非法,我们会调用super并抛出NameError

应对一般的简单查询,上面的做法不存在问题;但如果涉及到子查询的话,就另当别论了。前述实现对下面示例中的代码是无效的。

Delete.from[:table1].where do

exists(Select[:column2].from[:table2].where do

equal table1.column1, table2.column2

end)

end

不过我们可以使用eval与指定的binding一起,让上面的代码正常工作。此处的技巧是:将表名数组从外部的 block 隐式地传递到内部的 block 中。用显式方式传递会让 DSL 看起来很丑陋。

Select类的where方法中,我们使用blockbinding对象来得到Delete实例的tables集合。我们能够这样做,在于Delete实例的where方法被作为上下文(亦即blockbinding)传递给了select实例的where方法。binding对象(或上下文)是 block 被创建时的作用范围。下面的代码是对 where 方法的完整实现。

def where(&block)

@text += " where "

tables.concat(eval("respond_to?(:tables) ? tables : []",

block.binding)).inspect

instance_eval &block

end

我们把eval所在的语句拆开看看它都干了什么。它做的第一件事情是:

eval "respond_to?(:tables) ? tables : []", block.binding

它的作用是“在 block 的作用范围中对语句进行求解”。在当前例子中,block 的作用范围是:

Delete.from[:table1].where do .. end

这个范围是一个Delete类的实例,Delete 类中确实有tables方法,其作用是暴露表名数组(tables#=>[:table1])。因此,语句被求解后会返回表名数组。剩余的语句就可以看作:

tables.concat([:table1])

此句只是将所有的表名加入到tables数组中,并且可以被内部的 block 访问。有了这一行代码的处理,我们就可以让子查询产生正确的结果了。

delete from table1 where exists (select column2 from table2 where table1.column1 = table2.column2)

下面的代码可以产生上述结果,并且能够作为参考,以了解如何与 binding 一起使用 eval。

class Delete

def self.from

Delete.new

end

def [](*args)



@text = "delete from "

@text += args.join ","

@tables = args

self

end

attr_reader :tables

def where(&block)



@text += " where "

instance_eval &block

end

def exists(statement)



@text += "exists "

@text += statement

end

end

class Select



def self.[](*args)

self.new(*args)

end

def initialize(*columns)



@text = "select "

@text += columns.join ","

end

def from



@text += " from "

self

end

def [](*args)

@text += args.join ","

@tables = args

self

end

def tables



@tables

end

def where(&block)



@text += " where "

tables.concat(eval("respond_to?(:tables) ? tables : []", block.binding)).inspect

instance_eval &block

end

def method_missing(sym, *args)



super unless @tables.include? sym

klass = Class.new

klass.class_eval do

def initialize(table)

@table = table

end

def method_missing(sym, *args)



@table.to_s + "." + sym.to_s

end

end

klass.new(sym)

end

def equal(*args)



@text += args.join "="

end

end

结语

正如我们所看到的那样,使用 Ruby 提供的多种求解方法,我们可以创建简练、可读的代码;这些求解方法同时提供了创建诸如领域特定语言之类强大工具的能力。

关于作者

Jay Fields 是 ThoughtWorks 的一位开发人员。他总是在寻找令人兴奋的新技术,并愿意马上采用这些技术。他最近一段时间的工作中心放在领域特定语言(DSL)上面,所交付的应用为特定业务领域专家使用 DSL 撰写应用业务规则提供了强大的支持。

查看英文原文: Evaluation Options in Ruby
译者简介:郑柯,目前就职于一家医药电子商务公司,从事医用耗材电子商务平台的开发与维护。有志于在中国的软件开发业界推广 Agile 的理念和方法论,笃信以人为本,关注 Ruby,关注敏捷,关注人。

收藏

评论

微博

用户头像
发表评论

注册/登录 InfoQ 发表评论