ruby中的&操作符，以及各种闭包、proc的调用研究

 

class Array
  def iterate!(&code) #注意这里用了&符号
    self.each_with_index do |n,i|
      self[i] = code.call(n)
    end
  end
end

arr = [1,2,3,4]

arr.iterate! do |n|
  n ** 2
end
 
#[1, 4, 9, 16]

　　

今天读代码的时候，被这个&符号给蒙住了。ruby语言中时不时蹦出各种奇怪的符号，而且作用不明。还不好查得。

于是认真研究了一下。

&操作符的真正含义：proc对象和块之间的切换符号。&code 这是一个块， code 这是一个proc对象。简单的去掉&操作符，我们就能再次得到一个Proc对象。

===================================================

呃，其实如果没有上下文，完全说不清楚这段。还是看下面的例子吧，运行一趟就知道了。 

def math_by_anonymouse_block(a,b)
    yield a,b
end

def math_by_proc(a,b,a_proc)
    a_proc.call(a,b)
end

def math_by_named_block(a,b,&namedblock)

		puts "math_by_proc a,b,namedblock"
		puts namedblock.class # &namedblock 是一个区块，namedblock （去掉&）是一个proc，&操作符是个切换开关。
		puts math_by_proc a,b,namedblock
		puts "======="

		#lambda
		mylambda = lambda &namedblock
    puts mylambda.class
    puts math_by_anonymouse_block a,b,&mylambda
		#哈哈，下面这样也可以
		puts "math_by_proc a,b,mylambda"
		puts math_by_proc a,b,mylambda
		puts "======="

		#proc
    myproc = proc &namedblock
    puts myproc.class
    puts math_by_anonymouse_block a,b,&myproc
		#哈哈，下面这样也可以
		puts "math_by_proc a,b,myproc"
		puts math_by_proc a,b,myproc
		puts "======="

    #puts &namedblock.class

		#区块不能直接赋值给一个变量。但是可以通过方法来传递
    #myblock = &namedblock   #运行不通
    #puts myblock.class
		#所以我们用这种方式
		puts "math_by_anonymouse_block"
		puts math_by_anonymouse_block a,b,&namedblock
		puts "======="

end

math_by_named_block(2,3) {|x,y| x*y}

　

运行结果：

---------- ruby run ----------
math_by_proc a,b,namedblock
Proc
6
=======
Proc
6
math_by_proc a,b,mylambda
6
=======
Proc
6
math_by_proc a,b,myproc
6
=======
math_by_anonymouse_block
6
=======

输出完成 (耗时 0 秒) - 正常终止

　　

区块就像是方法的额外匿名参数，任何方法在调用时，都可以在后面跟一个区块。只不过如果这个方法中有yield语句，它就会调用区块，如果没有yield语句，就无视这个区块。

比如：

def my_noyield

　　puts "leave me alone. no yield !"

end

def my_yield
　　　　　　　　　　
　　puts "I call you! come on"
　　yield

end

my_noyield { puts "I'm coming！"}

my_yield { puts "I'm coming！"}

这是我们来定义一个带&操作符参数的方法，这就等于把之前的匿名参数变成了一个 &变量名 的参数。这个参数是一个也必然必须是一个 区块（不是proc，去掉&才是proc）

def my_third(&myproc)
	puts "I call you! come on"
	yield
end

my_third { puts "I'm coming！"}

这里 &myproc 是个区块，而myproc是个proc。对于proc，我们应该可以直接调用proc.call.

所以我们来试试第4个方法：不用yield，而在方法中直接call 这个proc

def my_fourth (&myproc)
	puts "I call you! come on"
	myproc.call
end

my_fourth { puts "I'm coming！"}

其实 &就是个切换开关，加上这个开关，就可以在proc和block之间切换。proc/lambda 也是一个开关（这两个是内核方法：Kernel#proc ：Creates a new procedure object from the given block. Equivalent to Proc.new .）

def my_fivth (&myproc)
	puts "I call you! come on"
	#&&myproc.call  这个不行，不能反转两次？
	c_proc = proc &myproc
	c_proc.call
end

my_fivth { puts "I'm coming！"}

def my_sixth (&myproc)
	puts "I call you! come on"
	c_proc = lambda &myproc
	c_proc.call
end

my_sixth { puts "I'm coming！"}

　　

补充一个小结：

可调用对象，有以下几种形式：块，proc，lambda，方法。不同类的可调用对象有细微区别。

但仍然可以通过以下方法在它们之间转换：包括Proc.new()方法，Methrod#to_proc()方法和&操作符。