Alex学Ruby[详解 block和Proc对象 2]

2008-06-24 00:44:50

Ruby Block Part Two
本部分内容是基于Ruby 1. 8. 7, 以后的系列都是1.8.7下测试。

例子1 ：

def return_using_procnew
  a_proc = Proc.new { return "Hi" }
  a_proc.call
  "Last line in the method"
end

=>  “ Hi”

def return_using_lambda
  a_proc = lambda { return "Hi" }
  a_proc.call
  "Last line in the method"
end
=> "Last line in the method"

以上例子可以看出lambda和Proc.new的区别，用lambda的时候return会被劫持，而Proc.new则不会。

例子2:

def foo(proc_one,proc_two)
  proc_two.call
  proc_one.call
end

foo(lambda {p "Proc 1"}, lambda {p "Proc 2"})     =>   "Proc 2"  "Proc 1"

def foo(proc_one,proc_two)
  proc_one.call
  proc_two.call
end

foo(lambda {p "Proc 1"}, lambda {p "Proc 2"})     =>   "Proc 1"    "Proc 2"

例子3:

def foo(&my_block)
   my_block.call
end

foo { puts "Hi" }
=>        Hi

foo (lambda{ puts "Hi" })
=> ArgumentError: wrong number of arguments (1 for 0)

def foo(a,&my_block)
  a.call
end

foo (lambda{ puts "Hi" })
=>   Hi

def foo(&my_block)
  my_block.call
end

foo { puts "Hi" }
=>  Hi

例子4:

1.times do
  x = 5
  closure = Proc.new {puts "In clsure value of x is #{x}
end

closure.call
=>     In clsure value of x is 5

x = 1

puts x
=>     1

closure.call
=>     In clsure value of x is 5

由此看出，闭包引用的变量是call这个proc对象时产生的变量，在外部修改其值是没用的。

例子5:

class GreetingGenerator
  def initialize(greeting)
    @my_block = lambda {|name| puts "#{greeting}, #{name}"}
  end
  def greet(name)
    @my_block.call name
  end
end
frenchGreeting = GreetingGenerator.new “Bonjour”
englishGreeting = GreetingGenerator.new “Hello”
frenchGreeting.greet “TinTin”
    =>     Bonjour, TinTin
englishGreeting.greet “Bunny”
    =>     Hello, Bunny

这你能看出来什么？
例子6:

def repeat(n)
  n.times {yield} if block_given?
end
repeat(2) {puts "Hi"}

def repeat2(n, &block)
  n.times {block.call} if block
end
repeat2(2) {puts "Hi2"}

def repeat3(n,&block)
  n.times {yield} if block
end
repeat3(2){ puts "Hi3" }

这三种写法的目的是一样的。
例子7:

  print  "(t)imes or (p)lus"

  times = gets

  print "number:"
  number =  Integer(gets)
  if times =~ /^t/
    calc = lambda {|n| n*number }
  else
    calc = lambda {|n| n + number}
  end

  p((1..10).collect(&calc).join(", "))

这个例子也是闭包的概念。
例子8:

words = %w(Daffy, Bugs, Alvin)
upcase_words = words.map( &:upcase )

p upcase_words

例子的map(&:upcase)相当于map{ |x| x.upcase }
这个是如何实现的？其实Symbol类内部实现了一个to_proc方法：

class Symbol
  def to_proc
    lambda { |x,*args| x.send(self, *args) }
  end
end

map方法只接受代码块，通过使用&可传递proc，来代替显示的使用代码块。而这个时候&被应用于不是proc的对象，而传进来的本身是个符号对象（:&upcase）,所以解释器自然而然的就会调用符号类的to_proc方法来得到一个proc。to_proc方法里的self引用的是对其调用了to_proc的符号。

本文出自 “{ :Alex Space => " Ruby Notes " }” 博客，请务必保留此出处http://blackanger.blog.51cto.com/140924/83701

上一篇 Alex学Ruby[详解 block和Proc对象]　　下一篇 Alex学Ruby[ class_eval(module_eval)现形记]

类别：Ruby on Rails ┆ 技术圈() ┆ 阅读() ┆ 评论() ┆推送到技术圈 ┆返回首页

相关文章

文章评论

[匿名]linjian

2008-06-24 12:25:30

这几篇都很有质量哈。是 The Ruby Way 上的吗?

blackanger

2008-06-25 11:16:57

这篇之前是我看the ruby way时候做的笔记。
这篇是RubyPlus的视频我做的笔记。

昵称：
验证码：		点击图片可刷新验证码　　博客过2级，无需填写验证码
内容：