本文的目的是為了找出為什么.NET程序員都想學(xué)習并使用Ruby，并探索Ruby語(yǔ)言的核心語(yǔ)法。
微軟的IronRuby項目為Windows平臺帶來(lái)了強大的動(dòng)態(tài)語(yǔ)言，Ruby編程語(yǔ)言是一個(gè)現代的，面向對象的基本語(yǔ)言，它的語(yǔ)法靈感來(lái)自Perl和Smalltalk語(yǔ)言，它是由一名日本人松本行弘（外號Matz）發(fā)明的，用他的話(huà)說(shuō)，他是想發(fā)明一種語(yǔ)言比Perl更強大，同時(shí)比Python更面向對象的編程語(yǔ)言，在“http://www.linuxdevcenter.com/pub/a/linux/2001/11/29/ruby.html”有一篇對松本行弘專(zhuān)訪(fǎng)文章，大家可以去看看。于是Ruby被設計為非常貼近自然語(yǔ)言，作者的原意就是要減少編程時(shí)候的不必要的瑣碎時(shí)間，令編寫(xiě)程序的人高興，他于1996年發(fā)布了1.0版本。
這么多年來(lái)，Ruby一直鮮為人知，但它的功能已經(jīng)遠遠超出了最初設計時(shí)的想法：以最簡(jiǎn)化的方法操作數據和環(huán)境。我第一次“玩”它還是在幾年前，那時(shí)我正在尋找一種替換處理自動(dòng)管理任務(wù)的批處理文件的方法。
Ruby真正開(kāi)始流行還得從一個(gè)來(lái)自伊利諾斯洲芝加哥市的名叫37signals小公司說(shuō)起，它們發(fā)布了一個(gè)名叫Rails的Web應用程序框架，這個(gè)新的框架吸取了已經(jīng)被證明是可靠的Model-View-Controller和ActiveRecord模型的經(jīng)驗，并且添加了一些新的思想，如convention over configuration，導致它實(shí)現了太多的目標，幾乎不需要編碼了。
RubyCLR和IronRuby
在2006年早些時(shí)候，John Lam發(fā)布了一個(gè)開(kāi)源項目，叫做RubyCLR，它在Ruby和.NET之間起到一個(gè)橋梁的作用，它允許用戶(hù)可以直接從Ruby訪(fǎng)問(wèn).NET平臺豐富的資源，甚至將Ruby對象都暴露給CLR了，這個(gè)項目非常有雄心，但它沒(méi)有打算將Ruby向.NET靠攏，而是打算讓這兩個(gè)世界相互對話(huà)，你仍然需要在你的機器上按照Ruby運行時(shí)環(huán)境。
RubyCLR項目為人們理解如何將Ruby和.NET和諧地溶合到一起邁出了關(guān)鍵的第一步，John的工作沒(méi)有引起人們的注意，2006年末，他在他的博客上宣布加入微軟新成立的動(dòng)態(tài)語(yǔ)言運行時(shí)環(huán)境（DLR）團隊，在John宣布前幾個(gè)月，微軟發(fā)布了IronPython的1.0版本，它是Python語(yǔ)言在.NET框架上一個(gè)新的實(shí)現，動(dòng)態(tài)語(yǔ)言運行時(shí)環(huán)境在IronPython上工作，它在.NET框架構建了一個(gè)運行環(huán)境，允許動(dòng)態(tài)語(yǔ)言進(jìn)入.NET。
John和他的團隊在2007年的MIX大會(huì )上宣布了IronRuby，可能真正讓人吃驚的是IronRuby項目本身是微軟的第一個(gè)真正意義上的開(kāi)源.NET語(yǔ)言，不僅可以得到源代碼，而且還可以獲取來(lái)自社區的貢獻。
IronRuby仍然處于發(fā)展階段，然而偶然也會(huì )刪掉已經(jīng)可以利用的東西，這些東西通常是其它項目的一部分，如最近發(fā)布的Silverlight 2.0 Beta 2，這些后續的項目也放在源代碼樹(shù)中了，并且也有相應的郵件列表。
為什么要學(xué)習Ruby？
我最喜歡的一本書(shū)叫做《程序員實(shí)務(wù)：從熟練工到大師》【英文名是《The Pragmatic Programmer: From Journeyman to Master》】，該書(shū)的作者鼓勵程序員每年學(xué)習一門(mén)新的編程語(yǔ)言，對于我而言，當我學(xué)習了Ruby語(yǔ)言后，大大地改變了我的專(zhuān)業(yè)范圍。
Ruby是一門(mén)完全面向對象的語(yǔ)言，這意味著(zhù)在系統中每一樣打交道的東西都是對象，包括直接的值，如數字，即使是類(lèi)，也是由新創(chuàng )建的對象實(shí)例組成的模板。
因為Ruby是一個(gè)動(dòng)態(tài)語(yǔ)言，你會(huì )發(fā)現類(lèi)型已經(jīng)變得不太重要了，當一個(gè)類(lèi)函數以參數形式獲取到一個(gè)對象時(shí)，不需要指定對象需要的類(lèi)型。實(shí)際上，Ruby沒(méi)有編譯器，因此，可能直到傳遞給類(lèi)函數的對象不滿(mǎn)足方法的需要時(shí)，你才會(huì )發(fā)現這一點(diǎn)。
如果你象我幾年前那樣，你也許會(huì )發(fā)現這個(gè)概念讓你不安，如果沒(méi)有編譯器，那么你可能要盡可能最快地在運行前就了解代碼中的錯誤，而不用等到運行時(shí)才知道。如果你還是習慣于讓編譯器告訴你錯誤，那你就不用選擇Ruby了。
正是由于以前編譯器能夠報告錯誤，如類(lèi)型不匹配，當你編寫(xiě)一個(gè)類(lèi)函數時(shí)，你可能希望“這里的對象必須能夠做到foo和bar”，然后創(chuàng )建一個(gè)接口叫做IFooBar，看起來(lái)這是一個(gè)不錯的解決方案，但當你想使用其它的在IfooBar之前創(chuàng )建的類(lèi)時(shí)（特別是那些來(lái)自框架的類(lèi)型），你就會(huì )失敗了。
作者提醒：IronRuby還沒(méi)有成為主流的工具，你可以使用Ruby的標準版本進(jìn)行學(xué)習，如果你想實(shí)驗后面的例子，可以從http://rubyinstaller.rubyforge.org/下載。
Ruby示例
學(xué)習Ruby或一門(mén)新的編程語(yǔ)言最好的方法就是多練習，研究它的交互接口，大多數動(dòng)態(tài)語(yǔ)言都有交互提示符，稱(chēng)之為讀-執行-打印環(huán)（即REPL，Read-Execute-Print Loop），Ruby中的REPL程序叫做irb（即交互式Ruby，interactive Ruby）。
當你執行irb程序時(shí)，你會(huì )看到一個(gè)irb提示符，如：
C:\Users\Brad＞ irb irb(main):001:0＞
當你在irb提示符后敲入命令時(shí)，Ruby解釋程序就會(huì )評估它們，并將結果輸出到你屏幕上，與irb類(lèi)似的REPL是學(xué)習一門(mén)語(yǔ)言的優(yōu)秀方法：每次一條語(yǔ)句。
下面對irb做一個(gè)簡(jiǎn)單的介紹，在irb提示符后，敲入5+2，并回車(chē)，告訴Ruby計算這個(gè)表達式的值：
irb(main):001:0＞ 5 + 2 =＞ 7
irb(main):001:0>部分是irb的提示符，當你敲入5+2并回車(chē)時(shí)，irb就將結果輸出到屏幕上，如這里的=> 7，=> 是irb顯示輸出結果時(shí)使用的提示符。
如果Ruby認為你還沒(méi)有完成表達式的書(shū)寫(xiě)，它允許你繼續換行書(shū)寫(xiě)，如當你敲入5+2+時(shí)就按了回車(chē)，Ruby認為你還有一部分沒(méi)有輸入完畢，它會(huì )繼續讓你在下一行輸入，如：
irb(main):002:0＞ 5 + 2 + irb(main):003:0* 13 =＞ 20
第二行的提示符變?yōu)樾翘枺?）了，而不是“>”，這樣你就知道你在完成前面沒(méi)有完成的表達式。
基礎類(lèi)型
如果一門(mén)編程語(yǔ)言不能處理數字，那就不值得學(xué)習和使用，Ruby當然能夠滿(mǎn)足算術(shù)運算了，如：
irb(main):004:0＞ 3 + 4 =＞ 7 irb(main):005:0＞ 3 * 4 =＞ 12 irb(main):006:0＞ 3 - 4 =＞ -1 irb(main):007:0＞ 3 / 4 =＞ 0 irb(main):008:0＞ 3.0 / 4.0 =＞ 0.75 irb(main):009:0＞ 0xF =＞ 15 irb(main):010:0＞ 0x3 * 0xA =＞ 30
正如你所看到的，Ruby支持整數和浮點(diǎn)類(lèi)型，甚至可以接收常用的十六進(jìn)制整數，但0x3 * 0xA的結果是以十進(jìn)制的形式顯示的，即顯示結果是30而不是0x1E。
因為在.NET中，數字也是真實(shí)的對象，因此，你可以在它們上面調用類(lèi)函數，如：
irb(main):011:0＞ 14.to_s =＞ "14"
在c++中不要這樣做。
to_s類(lèi)函數的功能是將一個(gè)對象轉換成一個(gè)字符串，因此，14.to_s返回的結果是"14"，和.NET中的to_string()函數一樣，to_s函數實(shí)際上是一個(gè)對象函數，因此，在Ruby中你可以將任何東西轉換成字符串。
字符串
Ruby的字符串具備完整的操作支持，如：
irb(main):012:0＞ "hello" + "there" =＞ "hellothere" irb(main):013:0＞ "Reader".length =＞ 6 irb(main):014:0＞ "Reader".reverse =＞ "redaeR" irb(main):015:0＞ "reader".capitalize =＞ "Reader" irb(main):016:0＞ "Reader".include?("foo") =＞ false irb(main):017:0＞ "Reader".include?("ade") =＞ true irb(main):018:0＞ " Reader ".strip =＞ "Reader" irb(main):019:0＞ "Reader".gsub("e", "f") =＞ "Rfadfr" irb(main):020:0＞ "Reader".delete("ea") =＞ "Rdr" irb(main):021:0＞ "a" ＜ "b" =＞ true
幾乎可以使用所有的字符串操作符，可能有的你還從來(lái)都沒(méi)有使用過(guò)，如下面的代碼按字母順序測試某個(gè)字符串是否位于其他兩個(gè)之間：
irb(main):022:0＞ "Bob".between? "Adam", "Chris" =＞ true
乘法操作符可以讓給定的字符串重復顯示指定的數量，如：
irb(main):023:0＞ "hi" * 5 =＞ "hihihihihi"
Crypt函數為字符串提供了一個(gè)單向哈希加密功能，在存儲敏感數據如密碼時(shí)就可以使用它，如：
irb(main):024:0＞ "Reader".crypt("ab") =＞ "abofgDjq6JNJo"
字符
Ruby沒(méi)有內置的字符類(lèi)型，它象數字一樣表現字符，可以是?語(yǔ)法來(lái)表示一個(gè)字符常量，你可以使用chr函數將一個(gè)數字轉換成一個(gè)等價(jià)的字符串，如：
irb(main):025:0＞ "Reader"[2] =＞ 97 irb(main):026:0＞ ?a =＞ 97 irb(main):027:0＞ 97.chr =＞ "a"
賦值
其實(shí)執行這個(gè)操作并沒(méi)什么用途，除非你可以將其存儲起來(lái)方便后面使用，如：
irb(main):028:0＞x = 42 =＞42
字符串有一個(gè)特殊的語(yǔ)法，允許嵌入式賦值，這個(gè)賦值不僅僅局限于簡(jiǎn)單的變量替換，它是一個(gè)完整的賦值，如：
irb(main):029:0＞ "The answer is #{x}!" =＞ "The answer is 42!" irb(main):030:0＞ "The answer is #{6 * 7}!" =＞ "The answer is 42!"
可以使用單引號將字符串引起來(lái)避免這種賦值，注意是單引號，不是雙引號，如：
irb(main):031:0＞ 'The answer is #{x}!' =＞ "The answer is \#{x}!"
數組
Ruby中的數組與.NET 1.0中的ArrayList類(lèi)很接近，它們的大小都是可變的，用于存儲任意類(lèi)型的數據，從0開(kāi)始編號，如：
irb(main):032:0＞ a = ["hello", 42, "world"] =＞ ["hello", 42, "world"] irb(main):033:0＞ a << 5.0 * 7.5 =＞ ["hello", 42, "world", 37.5] irb(main):034:0＞ a[0] =＞ "hello" irb(main):035:0＞ a[6] = 'hi' * 2 =＞ "hihi" irb(main):036:0＞ a =＞ ["hello", 42, "world", 37.5, nil, nil, "hihi"] irb(main):037:0＞ a[99] =＞ nil
前面的代碼顯示了如何使用<<操作符向數組末尾追加項目，以及獲取或設置值使用的指針操作符[]，當你向數組末尾添加一個(gè)項目時(shí)，Ruby使用零值填充數組中的“洞”，當你訪(fǎng)問(wèn)數組外的值時(shí)，Ruby返回零值而不是異常。
你可以使用一個(gè)范圍的指針將數組分片，也可以使用負的指針從后向前訪(fǎng)問(wèn)數組，-1就是最后一項，-2是倒數第二項，以此類(lèi)推，但不能使用反向范圍獲取反向分片，你可以使用一個(gè)正向范圍，然后調用reverse方法，如：
irb(main):038:0＞ a[-1] =＞ "hihi" irb(main):039:0＞ a[1..3] =＞[42, "world", 37.5] irb(main):040:0＞a[2..-2] =＞["world", 37.5, nil, nil] irb(main):041:0＞a[-4..-1] =＞[37.5, nil, nil, "hihi"] irb(main):042:0＞a[-1..-4] # 不能工作 =＞[] irb(main):043:0＞a[-4..-1].reverse # 能夠工作 =＞["hihi", nil, nil, 37.5]
和字符串一樣，你會(huì )發(fā)現有多個(gè)唯一對數組有用的類(lèi)函數，如：
irb(main):044:0＞ a =＞ ["hello", 42, "world", 37.5, nil, nil, "hihi"] irb(main):045:0＞ a.compact =＞ ["hello", 42, "world", 37.5, "hihi"] irb(main):046:0＞ a.join =＞ "hello42world37.5hihi" irb(main):047:0＞ [10, 75, 6, 29].sort =＞ [6, 10, 29, 75] irb(main):048:0＞ [[1, 2, 3], [4, 5, 6]] =＞ [[1, 2, 3], [4, 5, 6]] irb(main):049:0＞ [[1, 2, 3], [4, 5, 6]].flatten =＞ [1, 2, 3, 4, 5, 6]
散列
Ruby的最后一個(gè)核心數據結構是散列，與.NET 1.0中的散列表類(lèi)似，它是一個(gè)聯(lián)合數組，它的鍵值可以是任意類(lèi)型的值，它們指向的數據也可以是任意類(lèi)型的數據，實(shí)際上，大部分散列使用的是符號作為鍵值。
使用{}語(yǔ)法聲明散列，并且使用key => value格式聲明初始值，在散列中獲取或設置值時(shí)都可以使用鍵值操作符，如：
irb(main):050:0＞ h = {:foo=＞'bar', :baz=＞'biff'} =＞ {:foo=＞"bar", :baz=＞"biff"} irb(main):051:0＞ h[:foo] =＞ "bar" irb(main):052:0＞ h[:unknown] =＞ nil irb(main):053:0＞ h[:baz] = "new" =＞ "new" =＞ {:foo=＞"bar", :baz=＞"new"} irb(main):054:0＞ h.entries =＞ [[:foo, "bar"], [:baz, "new"]]
變量
Ruby中的變量和類(lèi)函數名都是以小寫(xiě)字母開(kāi)頭的，可以包括字母、數字和下劃線(xiàn)。本地變量沒(méi)有前綴，實(shí)例變量以@開(kāi)頭，全局變量以$開(kāi)頭。
在使用變量前無(wú)需聲明，未初始化的變量有一個(gè)零值，下面是幾個(gè)預定義的變量：
nil表示一個(gè)“無(wú)”對象，與.NET中的null類(lèi)似，除了nil是一個(gè)實(shí)例化的NilClass類(lèi)外。
true和false分別是實(shí)例化的TrueClass和FalseClass。
在類(lèi)函數中使用時(shí)，self指向調用類(lèi)函數的對象實(shí)例；在一個(gè)類(lèi)中使用時(shí)，它指的是實(shí)例化的類(lèi)對象本身。
__FILE__ 和__LINE__返回當前執行文件和那個(gè)文件中的行號。
符號
Ruby有一個(gè)特殊類(lèi)型的字符串，叫做符號，因為字符串在Ruby中是可以被修改的，使用它們作為散列鍵是很慢的，而且有一些情況是不能預測的。
除了它們是以冒號（:）開(kāi)頭外，符號的命名規則和變量的命名規則一致，你不能改變符號的值，兩個(gè)名字相同的符號它們的身份就一樣，它們可以作為優(yōu)秀的散列鍵，查找請求只需要比較整數值，而不是與一個(gè)可變長(cháng)字符串的值進(jìn)行對比。
類(lèi)
Ruby中的所有事物都是對象，所有對象都是類(lèi)的實(shí)例，為了探索類(lèi)是個(gè)什么東西，在它上面調用類(lèi)函數：
5.class =＞ Fixnum (2 ** 96).class =＞ Bignum 7.5.class =＞ Float (1..10).class =＞ Range "foo".class =＞ String /^foo[a-e]$/.class =＞ Regexp :foo.class =＞ Symbol [].class =＞ Array {}.class =＞ Hash
塊和閉包
雖然這與.NET 1.X中的事件處理程序類(lèi)似，但當你想處理它們時(shí)還是必須要定義完整的類(lèi)函數來(lái)連接這些事件，這就導致需要創(chuàng )建大量的類(lèi)函數，因為框架需要它。
.NET 2.0引入了匿名委派的概念，它們起的作用與Ruby中的塊類(lèi)似，如：
irb(main):001:0＞ h = {:foo=＞'bar', :hi=＞'there'} =＞ {:foo=＞"bar", :hi=＞"there"} irb(main):002:0＞ h.each_key {|k| puts k} foo hi =＞ {:foo=＞"bar", :hi=＞"there"} irb(main):003:0＞ h.each {|k,v| puts "#{k}: #{v}"} foo: bar hi: there =＞ {:foo=＞"bar", :hi=＞"there"}
正如你所看到的，Ruby中塊的語(yǔ)法是相當簡(jiǎn)潔的：通常使用一對大括號打開(kāi)塊和關(guān)閉塊，使用|x,y|語(yǔ)法標出傳遞給塊的變量。
Ruby中的塊和閉包類(lèi)似，正如.NET 2.0中的匿名委派，這意味著(zhù)它們有權訪(fǎng)問(wèn)它們封裝作用域的值，即使那個(gè)作用域退出后也可以訪(fǎng)問(wèn)。下面是一個(gè)將幾個(gè)值相乘的閉包示例：
irb(main):004:0＞ n = [5, 6, 10] =＞ [5, 6, 10] irb(main):005:0＞ t = 1 =＞ 1 irb(main):006:0＞ n.each { |i| t *= i } =＞ [5, 6, 10] irb(main):007:0＞ t =＞ 300
你甚至可以將引用存儲在塊中，方便以后使用，如：
irb(main):008:0＞ t = 1 =＞ 1 irb(main):009:0＞ f = lambda { |i| t *= i } =＞ # < PRE>
函數
Ruby中函數的定義比.NET簡(jiǎn)單多了，因為不需要指定類(lèi)型，如：
irb(main):001:0＞ def greet(name) irb(main):002:1＞ puts "Hello, #{name}!" irb(main):003:1＞ end =＞ nil irb(main):004:0＞ greet "Reader" Hello, Reader! =＞ nil irb(main):005:0＞ greet 42 Hello, 42! =＞ nil
Ruby執行的某些東西叫做“鴨式輸入”：如果它走起路來(lái)像鴨子或聲音也像鴨子，那它一定就是鴨子。你不用問(wèn)它“你是一只鴨子嗎？”，你只需要將它當做鴨子對它呷呷地叫就可以了，如果你渴望成為一只鴨子，只要你能呷呷地叫的就可以加入這個(gè)party。
注意greet函數定義時(shí)沒(méi)有對對象的類(lèi)型做任何限制，因為它只打印它們—Ruby中任何事物都是支持打印的，這得益于to_s類(lèi)函數的優(yōu)點(diǎn)，它可以將任何對象轉換成字符串，最終結果就是你可以greet它們。
下面是另一個(gè)例子：
irb(main):006:0＞ def print_len(item) irb(main):007:1＞ puts "Len = #{item.length}" irb(main):008:1＞ end =＞ nil irb(main):009:0＞ print_len "Reader" Len = 6 =＞ nil irb(main):010:0＞ print_len [1, 4, 9] Len = 3 =＞ nil irb(main):011:0＞ print_len 42 NoMethodError: undefined method ＜span class="pf"＞' ＜/span＞length' for 42:Fixnum from (irb):7:in ＜span class="pf"＞'＜/span＞print_len' from (irb):11
這里的print_len函數做的事情更多了：它調用了length函數。因此傳遞給print_len的是length函數的返回值，可以傳遞一個(gè)字符串或一個(gè)數組，因為它們都有對應的length函數，但是不能傳遞一個(gè)數字，因為沒(méi)有對應數字的length函數。
為了在.NET中編寫(xiě)一個(gè)類(lèi)似的函數，你可能需要創(chuàng )建一個(gè)IHaveLength接口作為你的參數類(lèi)型，由于在你創(chuàng )建接口前類(lèi)就已經(jīng)創(chuàng )建好了，所以不幸的是，可能你需要創(chuàng )建一個(gè)類(lèi)型轉換器。
從另一方面來(lái)看，至少你已經(jīng)有了IHaveLength，并且知道函數需要什么東西，既然類(lèi)型擔當的是某種格式文檔的角色，在動(dòng)態(tài)語(yǔ)言中你需要一個(gè)取舍，這樣你會(huì )在編寫(xiě)文檔和單元測試時(shí)更自信，可以幫助你識別類(lèi)或函數是如何使用的。
Ruby支持默認的參數值，如：
irb(main):012:0＞def repeat(val, times = 5) irb(main):013:1＞val.to_s * times irb(main):014:1＞end =＞nil irb(main):015:0＞repeat "hi" =＞"hihihihihi" irb(main):016:0＞repeat "hi", 3 =＞"hihihi" irb(main):017:0＞repeat 10, 3 =＞"101010"
注意在to_s * times前面沒(méi)有return，除非你明確地告訴它返回什么值，否則Ruby中的函數總是返回最后一個(gè)賦值，因此就不需要return關(guān)鍵字了。
Ruby支持變量參數，如：
irb(main):018:0＞ def add(*values) irb(main):019:1＞ result = 0 irb(main):020:1＞ values.each {|x| result += x} irb(main):021:1＞ result irb(main):022:1＞ end =＞ nil irb(main):023:0＞ add 1, 2, 3, 4, 5 =＞ 15
Ruby將變量參數打包成一個(gè)數組，然后你就可以訪(fǎng)問(wèn)傳遞來(lái)的值，并且可以將它們集合到一塊兒。
函數和變量命名約定
Ruby中的函數以小寫(xiě)字母開(kāi)頭，可以包含字母，數字和下劃線(xiàn)。改變基礎對象的函數名稱(chēng)以一個(gè)驚嘆號（!）結束，例如：upcase函數返回字符串的大寫(xiě)，但是還單獨保留了原始字符串；相反，upcase!函數就真實(shí)地改變了基礎字符串。
回答問(wèn)題（返回布爾值）的函數名稱(chēng)以一個(gè)問(wèn)號（?）結束。
類(lèi)
類(lèi)是來(lái)自新對象實(shí)例創(chuàng )建時(shí)的模板，例如：為了將前面的greet函數放入一個(gè)類(lèi)，你可能要編寫(xiě)以下代碼：
irb(main):001:0＞ class Manners irb(main):002:1＞ def greet(name) irb(main):003:2＞ puts "Hello, #{name}!" irb(main):004:2＞ end irb(main):005:1＞ end =＞ nil irb(main):006:0＞ m = Manners.new =＞ #< PRE irb(main):007:0＞ m.greet ?Reader? Hello, Reader!="＞" nil>
前面的代碼創(chuàng )建了一個(gè)新的類(lèi)，叫做Manners，并將函數greet添加到該類(lèi)中了，最后，它創(chuàng )建了一個(gè)Manners類(lèi)的實(shí)例，使用它greet Reader。
你可能認為在Ruby中類(lèi)是對象的活動(dòng)模板，與.NET中的類(lèi)不同，Ruby中的類(lèi)是編譯時(shí)定義的，你可以對其進(jìn)行任意擴展，當你完成擴展后，類(lèi)的現有實(shí)例也會(huì )立即得到新的反應，注意當你嘗試告訴它farewell時(shí)會(huì )發(fā)生什么，如：
irb(main):008:0＞ m.farewell "Reader" NoMethodError: undefined method 'farewell' for #＜Manners:0x404839c＞ from (irb):8
當你嘗試調用farewell時(shí)，系統會(huì )告訴你它不知道這是什么，那么就可以對Manners類(lèi)進(jìn)行擴展，讓它知道這么說(shuō)拜拜，如：
irb(main):009:0＞class Manners irb(main):010:1＞def farewell(name) irb(main):011:2＞puts "Goodbye, #{name}!" irb(main):012:2＞end irb(main):013:1＞end =＞nil irb(main):014:0＞m.farewell "Reader" Goodbye, Reader! =＞nil
擴展了Manners類(lèi)后，它的已有實(shí)例就會(huì )立即獲得這個(gè)新的功能。
Manners類(lèi)有兩個(gè)函數，兩個(gè)都需要你的名字，你可能需要重新編寫(xiě)它以便你創(chuàng )建它時(shí)可以傳遞名字給它，Ruby調用initialize函數，你傳遞的所有參數都傳遞給new，下面是更新后的Manners類(lèi)：
irb(main):001:0＞ class Manners irb(main):002:1＞ def initialize(name) irb(main):003:2＞ @name = name irb(main):004:2＞ end irb(main):005:1＞ def greet irb(main):006:2＞ puts "Hello, #{@name}!" irb(main):007:2＞ end irb(main):008:1＞ def farewell irb(main):009:2＞ puts "Goodbye, #{@name}!" irb(main):010:2＞ end irb(main):011:1＞ end =＞ nil irb(main):012:0＞ m = Manners.new "Reader" =＞ #< PRE m.greet Hello, Reader!="＞" nil @name="Reader" ＞ irb(main):013:0＞ irb(main):014:0＞ m.farewell Goodbye,>
注意類(lèi)在一個(gè)實(shí)例變量@name中存儲的名字，同時(shí)注意檢查實(shí)例包括所有實(shí)例變量的值。
你自己定義的類(lèi)可以隨意擴展，而且也可以擴展Ruby內置的類(lèi)，如：
irb(main):001:0＞ class Array irb(main):002:1＞ def print_tr irb(main):003:2＞ puts "＜tr＞" irb(main):004:2＞ each { |item| irb(main):005:3* puts " ＜td＞#{item}＜/td＞" irb(main):006:3＞ } irb(main):007:2＞ puts "＜/tr＞" irb(main):008:2＞ end irb(main):009:1＞ end =＞ nil Irb(main):010:0＞ ["hello","world!"].print_tr ＜tr＞ ＜td＞hello＜/td＞ ＜td＞world!＜/td＞ ＜/tr＞ =＞ nil
Rails對內置類(lèi)型添加了許多擴展屬性，提供了非常豐富的接口，例如：你可以編寫(xiě)類(lèi)似5.days.from_now這樣的代碼，返回從現在開(kāi)始5天后的日期。
迄今為止，你定義的函數都已經(jīng)成為實(shí)例函數，即它們僅在類(lèi)的實(shí)例中有效。Ruby也有靜態(tài)函數，有時(shí)也叫做類(lèi)函數。實(shí)際上，你已經(jīng)調用過(guò)一次靜態(tài)函數了，那就是new。
你可以在現有的類(lèi)上添加任何新的靜態(tài)函數，如：
irb(main):001:0＞ def String.concat(s1, s2) irb(main):002:1＞ s1 + ' ' + s2 irb(main):003:1＞ end =＞ nil irb(main):004:0＞ String.concat 'hi', 'bye' =＞ "hi bye"
你也可以使用self語(yǔ)法在定義或擴展類(lèi)的上下文中定義它們，如：
irb(main):001:0＞ class String irb(main):002:1＞ def self.concat(s1, s2) irb(main):003:2＞ s1 + ' ' + s2 irb(main):004:2＞ end irb(main):005:1＞ end =＞ nil irb(main):006:0＞ String.concat 'hi', 'bye' =＞ "hi bye"
反射
反射是運行時(shí)發(fā)現關(guān)于對象的信息的過(guò)程，你可以通過(guò)調用methods函數找到某個(gè)類(lèi)可用的函數，Ruby中的基礎類(lèi)也是對象，下面是查找在Ruby中對每個(gè)對象都有效的函數的代碼：
irb(main):001:0＞ o = Object.new =＞ #＜Object:0x3f8feb4＞ irb(main):002:0＞ o.methods =＞ ["inspect", "taguri", "clone", "public_methods" , "taguri=", "display", "instance_variable_defined ?", "equal?", "freeze", "methods", "respond_to?", ...many more methods listed...
調用methods函數返回的結果是一個(gè)字符串數組，包含了那個(gè)對象上有效的每個(gè)函數的名字，你也可以認為類(lèi)與散列非常相似，調用methods函數就與獲取散列表的鍵值相似。
你若不使用函數做點(diǎn)事情，你會(huì )覺(jué)得它很無(wú)趣，為了調用函數，你還可以使用send函數，如下面這兩條語(yǔ)句都是等效的：
irb(main):003:0＞ o.inspect =＞ "#＜Object:0x3f8feb4＞" irb(main):004:0＞ o.send "inspect" =＞ "#＜Object:0x3f8feb4＞"
通過(guò)在你的類(lèi)中定義method_missing函數，Ruby讓你有機會(huì )處理未知的函數，如：
irb(main):139:0＞ class Object irb(main):140:1＞ def method_missing(*args) irb(main):142:2＞ puts args irb(main):143:2＞ end irb(main):144:1＞ end =＞ nil irb(main):145:0＞ o.foobar 1, 2, 3 foobar 1 2 3 =＞ nil
正如你所看到的，傳遞給method_missing函數的參數包括請求的函數和所有傳遞給那個(gè)函數的參數，一個(gè)更好的定義如下：
def method_missing(method, *args)
元編程
即使Ruby沒(méi)有屬性，你也可以使用函數調用，通常不需要括弧來(lái)模擬屬性，你也需要影響Ruby以“=”結束函數的特殊處理方式，讓它們擔當調節器的作用。
你可以象下面這樣定義一個(gè)person類(lèi)：
irb(main):001:0＞ class Person irb(main):002:1＞ def age irb(main):003:2＞ @age irb(main):004:2＞ end irb(main):005:1＞ def age=(value) irb(main):006:2＞ @age = value irb(main):007:2＞ end irb(main):008:1＞ end =＞ nil
接下來(lái)就可以使用person類(lèi)的實(shí)例，將age當作person類(lèi)的一個(gè)屬性來(lái)處理，如：
irb(main):009:0＞p = Person.new =＞# < PRE irb(main):011:0＞p.age="42" ="＞nil" irb(main):012:0＞p.age="＞42">
如果你想將age的默認值設為一個(gè)非零的值，那么你可以使用initialize函數來(lái)設置。
這個(gè)代碼顯得非常標準，如果這是一個(gè)類(lèi)似c#的語(yǔ)言，你可能會(huì )使用類(lèi)似Visual Studio中片段，甚至靜態(tài)代碼的產(chǎn)生會(huì )自動(dòng)生成reader和writer的屬性。
在Ruby中，你可以使用元編程做一點(diǎn)努力就可以創(chuàng )建這些事物，理想情況下，你可以編寫(xiě)類(lèi)似下面這樣的代碼：
class Person prop :age end
你應該在對象上定義個(gè)類(lèi)（靜態(tài)）函數以便你在定義自己的類(lèi)時(shí)可以使用它，你也可以使用一個(gè)你還沒(méi)有看到過(guò)的函數，class_eval函數，如：
irb(main):001:0＞ class Object irb(main):002:1＞ def self.prop *names irb(main):003:2＞ names.each { |name| irb(main):004:3* self.class_eval " irb(main):005:3" def #{name} irb(main):006:3" @#{name} irb(main):007:3" end" irb(main):008:3＞ self.class_eval " irb(main):009:3" def #{name}=(value) irb(main):010:3" @#{name} = value irb(main):011:3" end" irb(main):012:3＞ } irb(main):013:2＞ nil irb(main):014:2＞ end irb(main):015:1＞ end =＞ nil
上面使用的class_eval函數是創(chuàng )建了另外一個(gè)函數結束的，它給字符串賦值，因此你可以在你的類(lèi)中編寫(xiě)自己的函數。
每個(gè)傳遞給prop函數的名字向新類(lèi)添加了兩個(gè)函數：getter和setter。最終使用你傳遞給prop的名字替換掉#{name}。
接下來(lái)，你可以在你的類(lèi)定義中使用prop了，如：
irb(main):016:0＞ class Person irb(main):017:1＞ prop :age, :name irb(main):018:1＞ irb(main):019:1* def initialize(age, name) irb(main):020:2＞ @age = age irb(main):021:2＞ @name = name irb(main):022:2＞ end irb(main):023:1＞ end =＞ nil irb(main):024:0＞ p = Person.new(36, "Brad") =＞ # < PRE @name="Brad" ＞ @age="36," irb(main):025:0＞ p.age="＞" 36 irb(main):026:0＞ p.name="＞" ?Brad?>
在你的環(huán)境中有了這些便利的工具后，你可以更快速地創(chuàng )建更高層次的類(lèi)，使用這些元編程技巧可以幫助你工作得更好，不需要依賴(lài)于編輯片段或編譯時(shí)代碼生成。
小結
本文只是對Ruby中便利工具做了一個(gè)皮毛介紹，今天學(xué)習好Ruby可以在當Ruby.在.NET和Silverlight中可用時(shí)幫助你，有這么強大的一個(gè)動(dòng)態(tài)編程語(yǔ)言，你的編程工具箱也會(huì )擴寬許多，但更重要的是，它可以幫助你開(kāi)始以一種新的方式思考問(wèn)題和解決方案。
