理解 Ruby 裏的 block

Ruby 裏的 block通常翻譯成代碼塊，block 剛開始看上去有點奇怪，由於不少語言裏面沒有這樣的東西。事實上它還不錯。

First-class function and Higher-order function

First-class function 和 Higher-order function 是函數式編程語言裏面的概念，聽起來好像很高端的樣子，其實很很簡單的。

First-class functions 是指在某些語言裏，函數是一等公民，能夠把函數當作參數傳遞，
能夠返回一個函數，能夠把函數賦值個一個變量等等，反正就是正常值能作的事函數都能作。JavaScript 就是這樣的。舉個例子(下面的全部例子裏，當我提到
JavaScript 時，示例代碼都用的 CoffeeScript)：

greet = (name) ->
  return -> console.log "Hello, #{name}"

greetToMike = greet("Mike")
greetToMike() # => 輸出 "Hello, Mike"
a = greetToMike
a() # => 輸出 "Hello, Mike"

在上面的第四行裏，greet("Mike") 返回了一個函數，因此第五行裏才能夠調用 greetToMike()輸出"Hello, Mike"。第六行把一個函數賦值給了a，因此第七行就能夠調用這個函數了。

higher-order function 通常翻譯成高階函數，是指接受函數作參數或者返回函數的函數。
舉個很是經常使用的例子（用 JavaScript）：

a = [ "a", "b", "c", "d" ]
a.map((x) -> x + '!') #=> ["a!", "b!", "c!", "d!"]

上面例子裏 map 就接受了一個匿名函數做爲參數。Array.prototype裏的不少方法，好比reduce, filter,every, some 等等都是高階函數，由於他們都接受函數做爲參數。

高階函數很是強大，表達力很強，能夠避免大量重複代碼。總的來講，它就是個好東西。

Block 的本質

先來看一組 Ruby 和 CoffeeScript 代碼的對比。

a = [ "a", "b", "c", "d" ]
a.map { |x| x + "!" } # => ["a!", "b!", "c!", "d!"]
a.reduce { |acc, x| acc + x} # => "abcd"

a = [ "a", "b", "c", "d" ]
a.map((x) -> x + '!') # => ["a!", "b!", "c!", "d!"]
a.reduce((acc, x) -> acc + x) # => "abcd"

這兩組代碼真的看起來超級像。我以爲這也暴露了 Ruby 的 block 的本質：高階函數的函數參數的變體。

JavaScript 裏面的map 函數接受一個函數做爲參數，可是 Ruby 裏的 map 卻接受一個
block 做爲參數。

其實 matz 早在一本書裏《松本行弘的程序世界》裏說了：

最終來看，塊究竟是什麼？
...
塊也能夠看做只是高階函數的一種特殊形式的語法。
...
高階函數和塊的本質同樣
...

在 Ruby 裏，函數不是一等公民，沒有 first-class functions。可是在 Ruby
裏怎樣使用高階函數呢？答案就是使用 block。能夠直接用 block，也能夠用 lambda
或者 proc 把 block 轉換成 Proc 類的實例用。

我發如今 Ruby 裏使用 block 時，幾乎全部的狀況下均可以用 JavaScript
的高階函數替代。

Enumerable 模塊裏的全部方法都是典型的例子。事實上確實存在 JavaScript 版
的 Enumerable，好比 Prototype.js 就有個 Enumerable，用起來跟 Ruby版的幾乎同樣的。固然它是經過高階函數實現的。

與高階函數有何不一樣

除了語法上看上去有點不一樣外，有很是重要的兩點。

控制流操做

在 block 裏面能夠用 break, next 等等這些在通常的循環裏纔有的控制流操做，這些
在高階函數裏是用不了的。好比你能夠試試在 JavaScript 裏用 forEach 而不用循環
實現個take_while 函數，真是至關彆扭的。好比以前 cnode 上就有人發帖問：nodejs的forEach不支持break嗎?，其實這個帖子下面回覆用 return 的基本上都是錯的，
some 和 every 這樣利用 短路求值 的特色確實能夠 hack 一下，可是明顯不天然並且大大增長了別人理解代碼的難度。

從這一點來看 block 確實還不錯的。

只有一個函數參數的高階函數

Ruby 裏一個方法只能接受一個 block 做爲參數，大概就是相似於只有一個函數參數的高階
函數。看起來好像是受到限制了。其實那本《松本行弘的程序世界》對此也有點解釋。
大概是說了一個調查，在傾向於使用高階函數的 OCaml 的標準庫中，94%
的高階函數只有一個函數參數。因此說這點限制不是什麼問題。就我本身的體驗來講，在 JavaScript 裏，還從沒用到須要兩個函數參數的高階函數。

未說明的

嗯，這篇文章看起來有點太長了，因此我不打算寫下去了。其實還有一些重要的地方沒說。好比
Block 其實能夠做爲閉包用的。Ruby 裏用def定義方法時有點悲劇的，由於它不是閉包，接觸
不到它外面的變量。

name = "mike"
def greet
  puts "hello, #{name}"
end
hello # => in `greet': undefined local variable or method `name' for main:Object (NameError)

可是用 block 就能夠了

name = "mike"
define_method(:greet) do
  puts "hello, #{name}"
end
greet # => "hello, mike"

用 JavaScript 就根本不存在問題。

name = "mike"
greet = -> console.log "hello, #{name}"
greet() # => "hello, mike"

同理還有class 和 module 關鍵字都會建立新的做用域而在裏面接觸不到外面的變量，
也能夠用 block 解決。

還有那個 proc 和 lambda 的區別。其實我一直不理解爲何會有人不用lambda
而跑去用 proc，明顯 proc 的 return 行爲太不符合常識了。可是到頭來卻發現
block 的行爲跟 proc 建立的對象的行爲是同樣的，好比

def hello
  (1..10).each { |e| return e}
  return "hello"
end
hello # => 1

這感受真是有點悲催。

結語

說了這麼多，就是由於在 Ruby 裏面函數不是一等公民，又想得到函數式編程的便利。

因此若是你以爲 Ruby 太複雜了，趕忙去學 Elixir，簡單優雅！