簡介： 假設您是一名 C++ 開發人員，您需要使用 Ruby 快速執行一些原型設計。當您拿起一本 Ruby 參考書籍（比如 Pickaxe）或瀏覽 Ruby 網站時，會看到一些熟悉的構造，比如類宣告、執行緒支援和異常處理。正當您認為自己瞭解 Ruby 的工作原理之時，您意識到了，您 Ruby 程式碼中的併發機制與 Boost 執行緒工作原理不一樣，catch 和 throw 也與它們看上去的大不相同，而且其他人在其 Ruby 指令碼中各處使用了名為 self 的關鍵詞。歡迎來到 Ruby 的世界中！
如果您是一名 C++ 程式設計師且需要在 Ruby 環境中工作，那麼您有一些功課要做。本文討論了 Ruby 新手可能會誤解的六個 Ruby 特性，特別是當他或她來自一個類似但又不太相同的環境，比如 C++：
● Ruby 類層次結構
● Ruby 中的單例方法
● self 關鍵詞
● method_missing 方法
● 異常處理
● 執行緒
注意：本文中所有的程式碼均進行測試，且基於 Ruby 版本 1.8.7。
Ruby 中的類層次結構
Ruby 中的類層次結構會很棘手。建立一個 Cat 型別的類並開始探討其層次結構（參見 清單 1）。
清單 1. Ruby 中的隱式類層次結構
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
irb(main):092:0> class Cat irb(main):093:1> end => nil irb(main):087:0> c = Cat.new => #<Cat:0x2bacb68> irb(main):088:0> c.class => Cat irb(main):089:0> c.class.superclass => Object irb(main):090:0> c.class.superclass.superclass => nil irb(main):091:0> c.class.superclass.superclass.superclass NoMethodError: undefined method `superclass' for nil:NilClass from (irb):91 from :0 |
Ruby 中的所有物件（甚至使用者定義的物件）都是 Object 類的後代，這在清單 1 中清晰可見。這與 C++ 是鮮明的對比。這一點也不像普通資料型別，例如 C/C++ int 或 double。清單 2 顯示了整數 1 的類層次結構。
清單 2. 整數 1 的類層次結構
|
1 2 3 4 5 6 7 8 |
irb(main):100:0> 1.class => Fixnum irb(main):101:0> 1.class.superclass => Integer irb(main):102:0> 1.class.superclass.superclass => Numeric irb(main):103:0> 1.class.superclass.superclass.superclass => Object |
到目前為止一切順利。現在您知道了類本身是 Class 型別的物件。而 Class 最終派生自 Object，如 清單 3 中所示使用 Ruby 內建的 String 類。
清單 3. 類的類層次結構
|
1 2 3 4 5 6 |
irb(main):100:0> String.class => Class irb(main):101:0> String.class.superclass => Module irb(main):102:0> String.class.superclass.superclass => Object |
Module 是 Class 的基類，但是使用它時有一點要注意，即您不能直接例項化使用者定義的 Module 物件。如果您不想深入 Ruby 內部，最好考慮與 C++ 名稱空間有類似特徵的 Module：您可以定義您自己的方法、常量、等等。您在 Class 中包含了一個 Module，以及 voilà，Module 的所有元素現在會魔法般地成為 Class 的元素。清單 4 提供了一個示例。
清單 4. Module 不能進行直接例項化，並且只能與類一同使用
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
irb(main):020:0> module MyModule irb(main):021:1> def hello irb(main):022:2> puts "Hello World" irb(main):023:2> end irb(main):024:1> end irb(main):025:0> test = MyModule.new NoMethodError: undefined method `new' for MyModule:Module from (irb):25 irb(main):026:0> class MyClass irb(main):027:1> include MyModule irb(main):028:1> end => MyClass irb(main):029:0> test = MyClass.new => #<MyClass:0x2c18bc8> irb(main):030:0> test.hello Hello World => nil |
下面再重申一下重點：當您使用 Ruby 編寫 c = Cat.new 時，c 是派生自 Object 的 Cat 型別的一個物件。Cat 類是 Class 型別的一個物件，Class 派生自 Module，而 Module 又派生自 Object。因此該物件及其型別都是有效的 Ruby 物件。
單例方法和可編輯類
現在，看一下單例方法。假設您想使用 C++ 建模類似於人類社會的東西。那麼您會如何做呢？定義一個名為 Human 的類，然後定義數百萬的 Human 物件？這更像是在建模一個呆板的社會；每個人必須具惟一的特徵。Ruby 的單例方法在這裡就派上了用場，如 清單 5 所示。
清單 5. Ruby 中的單例方法
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
irb(main):113:0> y = Human.new => #<Human:0x319b6f0> irb(main):114:0> def y.paint irb(main):115:1> puts "Can paint" irb(main):116:1> end => nil irb(main):117:0> y.paint Can paint => nil irb(main):118:0> z = Human.new => #<Human:0x3153fc0> irb(main):119:0> z.paint NoMethodError: undefined method `paint' for #<Human:0x3153fc0> from (irb):119 |
Ruby 中的單例方法 是僅與特定物件關聯的方法，不能用於一般的類。它們的字首是物件名稱。在 清單 5 中，paint 方法特定於 y物件，而且僅限於 y 物件；z.paint 導致一個 “方法未定義” 錯誤。您可以呼叫 singleton_methods 來查明一個物件中的單例方法列表：
|
1 2 |
irb(main):120:0> y.singleton_methods => ["paint"] |
不過在 Ruby 中有另一種定義單例方法的方式。看看 清單 6 中的程式碼。
清單 6. 建立單例方法的另一種方式
|
1 2 3 4 5 6 7 8 9 10 11 |
irb(main):113:0> y = Human.new => #<Human:0x319b6f0> irb(main):114:0> class << y irb(main):115:1> def sing irb(main):116:1> puts "Can sing" irb(main):117:1> end irb(main):118:1>end => nil irb(main):117:0> y.sing Can sing => nil |
清單 5 還開創了新的可能性，可以新增新方法到使用者定義的類和內建的 Ruby 現有類，比如 String。這在 C++ 中是不可能實現的，除非您能夠訪問您使用的類的原始碼。再次觀察 String 類（清單 7）。
清單 7. Ruby 允許您修改一個現有的類
|
1 2 3 4 5 6 7 8 9 10 11 |
irb(main):035:0> y = String.new("racecar") => "racecar" irb(main):036:0> y.methods.grep(/palindrome/) => [ ] irb(main):037:0> class String irb(main):038:1> def palindrome? irb(main):039:2> self == self.reverse irb(main):040:2> end irb(main):041:1> end irb(main):050:0> y.palindrome? => true |
清單 7 清楚地展示瞭如何編輯一個現有的 Ruby 類來新增您自行選擇的方法。這裡，我新增了 palindrome? 方法到 String 類。因此 Ruby 類在執行時是可編輯的（一個強大的屬性）。
現在您對 Ruby 的類層次結構和單例有了一定的認識，接下來我們來看 self。注意，在定義 palindrome? 方法時我使用了 self。
發現 self
self 關鍵詞的最常見用法可能就是在 Ruby 類中宣告一個靜態方法，如 清單 8 所示。
清單 8. 使用 self 宣告類的靜態方法
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
class SelfTest def self.test puts "Hello World with self!" end end class SelfTest2 def test puts "This is not a class static method" end end SelfTest.test SelfTest2.test |
從 清單 8 的輸出中可以看到（如 清單 9 所示），沒有物件您無法呼叫非靜態方法。該行為類似於 C++。
清單 9. 在沒有物件的情況下呼叫非靜態方法時會出錯
|
1 2 3 4 5 6 |
irb(main):087:0> SelfTest.test Hello World with self! => nil irb(main):088:0> SelfTest2.test NoMethodError: undefined method 'test' for SelfTest2:Class from (irb):88 |
在探討 self 更深奧的用途和含義之前，注意您也可以通過在方法名稱前面加上類名來在 Ruby 中定義一個靜態方法：
|
1 2 3 4 5 6 7 |
class TestMe def TestMe.test puts "Yet another static member function" end end TestMe.test # works fine |
清單 10 提供了 self 的一個更有趣但不太容易找到的用法。
清單 10. 使用元類來宣告靜態方法
|
1 2 3 4 5 6 7 8 9 |
class MyTest class << self def test puts "This is a class static method" end end end MyTest.test # works fine |
該段程式碼以一種稍微不同的方式將 test 定義為一個類靜態方法。要了解究竟發生了什麼，您需要看一下 class << self 語法的一些細節。class << self … end 建立一個元類。在方法查詢鏈中，在訪問物件的基類之前先搜尋該物件的元類。如果您在元類中定義一個方法，可以在類上呼叫該方法。這類似於 C++ 中靜態方法的概念。
可以訪問一個元類嗎？是的：只需從 class << self … end 內返回 self。注意，在一個 Ruby 類宣告中，您沒有義務僅給出方法定義。清單 11 顯示了元類。
清單 11. 理解元類
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
irb(main):198:0> class MyTest irb(main):199:1> end => nil irb(main):200:0> y = MyTest.new => #< MyTest:0x2d43fe0> irb(main):201:0> z = class MyTest irb(main):202:1> class << self irb(main):203:2> self irb(main):204:2> end irb(main):205:1> end => #<Class: MyTest > irb(main):206:0> z.class => Class irb(main):207:0> y.class => MyTest |
回到 清單 7 的程式碼，您會看到 palindrome 被定義為 self == self.reverse。在該上下文中，self 與 C++ 沒有什麼區別。C++和 Ruby 中的方法都需要一個操作物件，以修改或提取狀態資訊。self 是指這裡的這個物件。注意，可以通過附加 self 字首來選擇性地呼叫公共方法，指明方法付諸作用的物件，如 清單 12 所示。
清單 12. 使用 self 呼叫方法
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
irb(main):094:0> class SelfTest3 irb(main):095:1> def foo irb(main):096:2> self.bar() irb(main):097:2> end irb(main):098:1> def bar irb(main):099:2> puts "Testing Self" irb(main):100:2> end irb(main):101:1> end => nil irb(main):102:0> test = SelfTest3.new => #<SelfTest3:0x2d15750> irb(main):103:0> test.foo Testing Self => nil |
在 Ruby 中您無法通過附加 self 關鍵詞字首來呼叫私有方法。對於一名 C++ 開發人員，這可能會有點混淆。清單 13 中的程式碼明確表示，self 不能用於私有方法：對私有方法的呼叫只能針對隱式物件。
清單 13. self 不能用於私有方法呼叫
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
irb(main):110:0> class SelfTest4 irb(main):111:1> def method1 irb(main):112:2> self.method2 irb(main):113:2> end irb(main):114:1> def method3 irb(main):115:2> method2 irb(main):116:2> end irb(main):117:1> private irb(main):118:1> def method2 irb(main):119:2> puts "Inside private method" irb(main):120:2> end irb(main):121:1> end => nil irb(main):122:0> y = SelfTest4.new => #<SelfTest4:0x2c13d80> irb(main):123:0> y.method1 NoMethodError: private method `method2' called for #<SelfTest4:0x2c13d80> from (irb):112:in `method1' irb(main):124:0> y.method3 Inside private method => nil |
由於 Ruby 中的一切都是物件，當在 irb 提示符上呼叫 self 時您會得到以下結果：
|
1 2 3 4 |
irb(main):104:0> self => main irb(main):105:0> self.class => Object |
一啟動 irb，Ruby 直譯器就為您建立主物件。這一主物件在 Ruby 相關的文章中也被稱為頂層上下文。
關於 self 就介紹這麼多了。下面我們接著來看動態方法和 method_missing 方法。
method_missing 揭祕
看一下 清單 14 中的 Ruby 程式碼。
清單 14. 執行中的 method_missing
|
1 2 3 4 5 6 7 8 9 10 11 |
irb(main):135:0> class Test irb(main):136:1> def method_missing(method, *args) irb(main):137:2> puts "Method: #{method} Args: (#{args.join(', ')})" irb(main):138:2> end irb(main):139:1> end => nil irb(main):140:0> t = Test.new => #<Test:0x2c7b850> irb(main):141:0> t.f(23) Method: f Args: (23) => nil |
顯然，如果 voodoo 是您喜歡的，那麼清單 14 會給您這個恩典。這裡發生什麼了呢？我們建立了一個 Test 型別的物件，然後呼叫了t.f，以 23 作為引數。但是 Test 沒有以 f 作為方法，您應當會得到一個 NoMethodError 或類似的錯誤訊息。Ruby 在這裡做了一件很棒的事情：您的方法呼叫被阻截並由 method_missing 處理。method_missing 的第一個引數是缺失的方法名，在本例中是f。第二個（也是最後一個）引數是 *args，該引數捕獲傳遞給 f 的引數。您可以在何處使用像這樣的引數呢？在眾多選項之中，您可以輕鬆地將方法呼叫轉發到一個包含的 Module 或一個元件物件，而不為頂級類中的每個呼叫顯式提供一個包裝應用程式程式設計介面。
在 清單 15 中檢視更多 voodoo。
清單 15. 使用 send 方法將引數傳遞給一個例程
|
1 2 3 4 5 6 7 8 9 10 |
irb(main):142:0> class Test irb(main):143:1> def method1(s, y) irb(main):144:2> puts "S: #{s} Y: #{y}" irb(main):145:2> end irb(main):146:1> end => nil irb(main):147:0>t = Test.new irb(main):148:0> t.send(:method1, 23, 12) S: 23 Y: 12 => nil |
在 清單 15 中，class Test 有一個名為 method1 的方法被定義。但是，這裡沒有直接呼叫方法，而是發出對 send 方法的呼叫。send 是 Object 類的一個公共方法，因此可用於 Test（記住，所有類都派生自 Object）。send 方法的第一個引數是表示方法名稱的一個符號和字串。send 方法可以做到哪些您通常無法做到的事情？您可以使用 send 方法訪問一個類的私有方法。當然，對於這是否是一個好特性仍然頗具爭議。看一下 清單 16 中的程式碼。
清單 16. 訪問類私有方法
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
irb(main):258:0> class SendTest irb(main):259:1> private irb(main):260:1> def hello irb(main):261:2> puts "Saying Hello privately" irb(main):262:2> end irb(main):263:1> end => nil irb(main):264:0> y = SendTest.new => #< SendTest:0x2cc52c0> irb(main):265:0> y.hello NoMethodError: private method `hello' called for #< SendTest:0x2cc52c0> from (irb):265 irb(main):266:0> y.send(:hello) Saying Hello privately => nil |
如果您像我一樣具有 C++ 工作背景，且試圖編寫異常安全程式碼，那麼在看到 Ruby 有 throw 和 catch 關鍵詞時會開始感到異常親切。遺憾的是，throw 和 catch 在 Ruby 中的含義完全不同。
Ruby 通常使用 begin…rescue 塊處理異常。清單 17 提供了一個示例。
清單 17. Ruby 中的異常處理
|
1 2 3 4 5 6 7 8 9 |
begin f = File.open("ruby.txt") # .. continue file processing rescue ex => Exception # .. handle errors, if any ensure f.close unless f.nil? # always execute the code in ensure block end |
在 清單 17 中，如果在試圖開啟檔案時出錯（可能是缺少檔案或檔案許可權方面的問題），rescue 塊中的程式碼會執行。ensure 塊中的程式碼始終執行，不管是否有任何異常引發。注意，rescue 塊後面是否緊跟 ensure 塊是可選的。另外，如果必須顯式地丟擲一個異常，那麼語法是 raise <MyException>。如果您選擇擁有您自己的異常類，可能會希望從 Ruby 內建的 Exception 類派生出相同的類，以利用現有方法。
Ruby 中的 catch 和 throw 程式碼塊實際上不是異常處理：您可以使用 throw 修改程式流程。清單 18 顯示了一個使用 throw 和 catch的示例。
清單 18. Ruby 中的 Throw 和 catch
|
1 2 3 4 5 6 7 |
irb(main):185:0> catch :label do irb(main):186:1* puts "This will print" irb(main):187:1> throw :label irb(main):188:1> puts "This will not print" irb(main):189:1> end This will print => nil |
在 清單 18 中，當程式碼執行到 throw 語句時，執行會被中斷，直譯器開始尋找處理相應符號的一個 catch 塊。在 catch 塊結束的地方繼續執行。檢視 清單 19 中的 throw 和 catch 示例：注意，您可以輕鬆將 catch 和 throw 語句用於各個函式。
有些人甚至說，Ruby 中對 catch 和 throw 的支援將 C goto 行為帶到一個全新的高度。鑑於函式可以有多個巢狀層，而 catch 塊可能在每一級，goto 行為類比似乎有據可循。
清單 19. Ruby 中的異常處理：巢狀的 catch 塊
|
1 2 3 4 5 6 7 8 9 10 |
irb(main):190:0> catch :label do irb(main):191:1* catch :label1 do irb(main):192:2* puts "This will print" irb(main):193:2> throw :label irb(main):194:2> puts "This won't print" irb(main):195:2> end irb(main):196:1> puts "Neither will this print" irb(main):197:1> end This will print => nil |
Ruby 中的執行緒可以是綠色的
Ruby 版本 1.8.7 不支援真正的併發性。確實不支援。但是您會說，在 Ruby 中有 Thread 建構函式。您說的沒錯。不過這個Thread.new 不會在您每次呼叫同一方法時生成一個真實的作業系統執行緒。Ruby 支援的是綠色執行緒：Ruby 直譯器使用單一作業系統執行緒來處理來自多個應用程式級執行緒的工作負載。
當某個執行緒等待一些輸入/輸出發生時，這一 “綠色執行緒” 概念很有用，而且您可以輕鬆排程一個不同的 Ruby 執行緒來充分利用 CPU。但是這一建構函式無法使用現代的多核 CPU（維基百科提供了一段內容，很好地解釋了什麼是綠色執行緒。參見 參考資料 獲取連結）。
最後這一個示例（參見 清單 20）證明了這一點。
清單 20. Ruby 中的多個執行緒
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
#!/usr/bin/env ruby def func(id, count) i = 0; while (i < count) puts "Thread #{i} Time: #{Time.now}" sleep(1) i = i + 1 end end puts "Started at #{Time.now}" thread1 = Thread.new{func(1, 100)} thread2 = Thread.new{func(2, 100)} thread3 = Thread.new{func(3, 100)} thread4 = Thread.new{func(4, 100)} thread1.join thread2.join thread3.join thread4.join puts "Ending at #{Time.now}" |
假設您的 Linux® 或 UNIX® 機器上擁有 top 實用程式，在終端執行程式碼，獲取程式 ID，然後再執行 top –p <process id>。top啟動後，按住 Shift-H 來列出執行中執行緒的數量。您應當只能看到一個執行緒，確認了這一點：Ruby 1.8.7 中的併發性不過是個神話。
總的看來，綠色執行緒沒有什麼壞處。它們在重負荷輸入/輸出密集型程式中仍然有用，更不用說該方法可能是作業系統間最可移植的一個了。
結束語
本文涵蓋了以下多個方面：
● Ruby 中類層次結構的概念
● 單例方法
● 解釋 self 關鍵詞和 method_missing 方法
● 異常
● 執行緒
儘管 Ruby 不乏特立獨行之處，但是使用它進行程式設計還是挺有趣的，而且其以最少的程式碼完成大量工作的能力還是很強大的。難怪 Twitter 這樣的大型應用程式會使用 Ruby 來駕馭其真正的潛力。祝您有個快樂的 Ruby 程式設計體驗！