代码块是什么？

代码块是由 {...} 或 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