創(chuàng)建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

＆，將代碼塊作為非匿名參數(shù)傳遞

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創(chuàng)建的Proc叫l(wèi)ambda，用其他方式創(chuàng)建的Proc稱為proc。
可以使用Proc#lambda?來檢測Proc是不是lambda
使用->方法創(chuàng)建之后: p.lambda? 返回為True

• proc 與lambda ，return的區(qū)別

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里面返回

• 參數(shù)

lambda會嚴格檢查參數(shù)。
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 就是作為一個參數(shù)傳遞進去而已。