代码块是什么？
代码块是由 {...} 或 do..end 包围起来的一块代码。
代码块通常用于实现自定义的运算，有点像匿名方法。
代码块也可以作为Proc对象赋值给指定的变量（非匿名）。
因为以上特性，代码块提供了函数式编程的特性，如闭包等。
匿名与非匿名代码块
我们默认 block 为匿名代码块，proc 为非匿名代码块。
使用 proc 的好处是它可以存放在变量中，以便于重复使用。
block 通过 yield 关键字来调用，proc 通过 call 方法来调用。
block 跟在方法调用后(单次)，proc 可作为参数多次传入方法中(多次)。
# implicit code block
def calculation(a, b)
yield(a, b)
end
calculation(5, 6) { |a, b| a + b } # addition block #=> 11
calculation(5, 6) { |a, b| a - b } # subtraction block #=> -1
# explicit code block (lambda)
def calculation(a, b, operation)
operation.call(a, b)
end
addition_block = lambda { |a, b| a + b } # addition block
subtraction_block = lambda { |a, b| a - b } # subtraction block
calculation(5, 6, addition_block) # addition #=> 11
calculation(5, 6, subtraction_block) # subtraction #=> -1
匿名与非匿名的相互转化
block 和 proc 是可以通过 & 符号相互转化的：
开头带&符号的整体 (&foo) 可以看做是一个 block，
通过引用去掉& 符号后的 foo 变量及为它对应的 proc 对象。
# implicit -> explicit
def calculation1(a, b, &block)
block.class #=> Proc
block.call(a, b)
end
calculation1(1, 2) { |a, b| a + b } # => 3
addition_lambda = -> (a, b) { a + b }
calculation1(1, 2, &addition_lambda) # => 3
# explicit -> implicit
def calculation2(a, b)
yield(a, b) if block_given?
end
calculation2(5, 5) { |a, b| a + b } # => 10
addition = -> (a, b) { a + b }
calculation2(5, 5, &addition) # => 10
lambda vs proc
相同点
二者都是 Proc 类的对象
proc { 'foo' }.class # => Proc
lambda { 'bar' }.class # => Proc
lambda 有语法糖，上面可以简写成 -> { 'bar' }
proc 也可以通过 Proc.new { 'foo' } 实例化对象。
不同点
lambda 要比 proc 更加严格，更像是匿名方法。
1.返回值 return，lambda 从当前代码块返回，proc 从当前代码块所在的作用域返回。
2.代码块参数检验，lambda 参数检验更加严格，多了少了都会报错，而 proc 则不会。
我们可以通过调用 Proc#lambda? 来区分他们。
Tips: block/proc/lambda 都可使用 next 关键字退出代码块，与在 lambda 中 return 的用法相同。由于怪异的返回语法，在 proc 中尽量避免使用 return，除非你确实熟练掌握了它，并且真的需要使用这个特性。
def a_method
puts lambda { return "we just returned from the block" }.call
puts "we just returned from the calling method"
end
a_method
#---output---
# we just returned from the block
# we just returned from the calling method
def a_method
puts proc { return "we just returned from the block" }.call
puts "we just returned from the calling method"
end
result = a_method
puts result
#---output---
# we just returned from the block
什么是闭包(Closure)
闭包是函数式编程中的一个重要特性。
我的理解就是他能穿透作用域，访问代码块上下文的局部变量。
Wikipedia: ‘Closure is a function or a reference to a function together with a referencing environment. Unlike a plain function, closures allow a function to access non-local variables even when invoked outside of its immediate lexical scope.’
代码块的其他实用技巧
Kernel#block_given?: 这个方法用来判断该方法在调用时有没有接受到匿名代码块 (注意：这里仅用于判断是否有匿名代码块传入，当未传入代码块或传入的是非匿名代码块时:block_given返回false)。最佳应用场景：使用它的目的通常是在你用yield之前判断是否有匿名代码块可以操作。如果未添加匿名代码块且使用yield关键字，解释器会抛出LocalJumpError的异常错误并伴随着错误提示no block is given。所以每次使用yield前都确保用:block_given来判断，这样就没事了 :D匿名代码块语法糖：
(1..3).map(&:to_s) #=> ["1", "2", "3"]
&会触发后面的 symbol:to_s调用自身的Symbol#to_proc方法，再通过&将 proc 转化为一个匿名的 block 传给 map 方法。
Play with Code Block
- 将非匿名代码块作为参数传入方法中，再转化为匿名代码块使用。
def filter(array, block)
array.select(&block)
end
arr = [1, 2, 3 ,4 ,5]
choose = -> (n) { n < 3}
filter arr, choose # => [1, 2]
# explain: 'select' should receive implicit code block,
# the second parameter of the 'filter; method is lambda,
# so use '&block' to convert lambda to implicit block.
- 将匿名代码块传入非匿名代码块中，依然作为匿名代码块使用。
filter_block = lambda do |array, &block|
array.select(&block)
end
filter_block.call([1, 2, 3, 4]) { |number| number.even? } #=> [2, 4]
filter_block.call([1, 2.0, 3, 4.0]) { |number| number.integer? } #=> [1, 3]
- 将方法转化为 proc 对象，再转化为匿名代码块被方法使用。
def say; yield; end
def hi; "hi"; end
def hello; "hello"; end
say &method(:hi).to_proc # => "hi"
say &method(:hello).to_proc # => "hello"
- 方法转化为代码块传入其他方法中使用。
def plus a, b
a + b
end
def plusplus a, b, c, d, &plus
block_given? ? yield(a+b, c+d) : 0
end
plusplus 1, 2, 3, 4, &method(:plus).to_proc # => 10
- 计算器小程序
# complex example
def calculation(*operations, calculator_lambda)
operations.each do |operation|
num1 = operation[0]
num2 = operation[1]
operator = operation[2]
puts calculator_lambda.call(num1, num2, operator)
end
end
#
calculator_lambda = -> (a, b, op) do
next a + b if op == '+'
next a - b if op == '-'
next a * b if op == '*'
next a / b if op == '/'
raise 'invalid operator'
end
#
operation1 = [1, 2, '+'] # 1 + 2 = 3
operation2 = [6, 3, '/'] # 6 / 3 = 2
calculation(operation1, operation2, calculator_lambda)
#
#---output---
# 3
# 2