创建Proc对象

• Proc.new

 p = Proc.new { |m| m+1 }
p.call(3) #=> 4

• proc

p = proc { |m| m+ 1 }
p.call(3) #=>4

• lambda

la = lambda { |m| m + 1 }
la.class #=> Proc
la.call(3) # => 4

• ->

p = ->(m) { m + 1}
p.call(3) #=> 4

＆，将代码块作为非匿名参数传递

def math(a,b)
   yield(a,b)
end
def do_math(a,b,&operation)
   math(a,b,&operation) 
end
do_math(2,3) { |x,y| x + y} #=>5

• &操作符的含义

def my_method(&my_proc)
   my_proc
end
p = my_method { |name|  "Hello, #{name.capitalize}" }
p.call("getsuKami") # => Hello, GetsuKami

&操作符的含义是：这是一个Proc对象，我想把他当成代码块来使用。最掉&操作符，就能再次得到一个Proc对象。

def my_method(name)
 "#{name}, #{yield}"
end
my_proc = proc { "Hello" }
my_method("Bob", &my_proc) # => Bob,Hello

Proc与Lambda的对比

用Lambda创建的Proc叫lambda，用其他方式创建的Proc称为proc。
可以使用Proc#lambda?来检测Proc是不是lambda
使用->方法创建之后: p.lambda? 返回为True

• proc 与lambda ，return的区别

proc 会从定义proc的作用域中返回，而lambda只是从lambda中返回。

def double(my_lambda)
   my_lambda.call *  2
end

def an_double
   p = Proc.new { return 10 }　　＃在这定义
   result = p.call  #在这里程序就被返回，就是从an_double的作用域返回
   return result * 2  #
end

def ann_double(my_proc)
   my_proc.call * 2
end

la = lambda { return 10 }
double(la) #=>20

an_double #=> 10

p = Proc.new { return 10 } #定义在main中
# ann_double(p) #=> error,不能main里面返回

• 参数

lambda会严格检查参数。
proc不会，如果多了，就忽略后面多的，如果少了，就用nil代替。

yield and self

yield 对代码块的调用
self 对当前对象的引用

class A
  def hello1
    yield self if block_given?
  end
  def hello2
    yield 1 if block_given?
  end
  def self.hello
    yield self if block_given?
  end
end

A.new.hello1 { |var| p var} #=>#<A:0x0000000147eef0>
A.new.hello2 { |var| p var} # => 1
A.hello { |var| p var } # => A

self 就是作为一个参数传递进去而已。