基礎(chǔ)類型

如果一門編程語言不能處理數(shù)字，那就不值得學習和使用，Ruby當然能夠滿足算術(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支持整數(shù)和浮點類型，甚至可以接收常用的十六進制整數(shù)，但0x3 * 0xA的結(jié)果是以十進制的形式顯示的，即顯示結(jié)果是30而不是0x1E。

因為在.NET中，數(shù)字也是真實的對象，因此，你可以在它們上面調(diào)用類函數(shù)，如：

irb(main):011:0＞ 14.to_s
                =＞ "14"

在c++中不要這樣做。

to_s類函數(shù)的功能是將一個對象轉(zhuǎn)換成一個字符串，因此，14.to_s返回的結(jié)果是"14"，和.NET中的to_string()函數(shù)一樣，to_s函數(shù)實際上是一個對象函數(shù)，因此，在Ruby中你可以將任何東西轉(zhuǎn)換成字符串。

字符串

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
                

幾乎可以使用所有的字符串操作符，可能有的你還從來都沒有使用過，如下面的代碼按字母順序測試某個字符串是否位于其他兩個之間：

irb(main):022:0＞ "Bob".between? "Adam", "Chris"
                =＞ true
                

乘法操作符可以讓給定的字符串重復顯示指定的數(shù)量，如：

irb(main):023:0＞ "hi" * 5
                =＞ "hihihihihi"
                

Crypt函數(shù)為字符串提供了一個單向哈希加密功能，在存儲敏感數(shù)據(jù)如密碼時就可以使用它，如：

irb(main):024:0＞ "Reader".crypt("ab")
                =＞ "abofgDjq6JNJo"
                

字符

Ruby沒有內(nèi)置的字符類型，它象數(shù)字一樣表現(xiàn)字符，可以是?語法來表示一個字符常量，你可以使用chr函數(shù)將一個數(shù)字轉(zhuǎn)換成一個等價的字符串，如：

irb(main):025:0＞ "Reader"[2]
                =＞ 97
                irb(main):026:0＞ ?a
                =＞ 97
                irb(main):027:0＞ 97.chr
                =＞ "a"
                

賦值

其實執(zhí)行這個操作并沒什么用途，除非你可以將其存儲起來方便后面使用，如：

irb(main):028:0＞x = 42
                =＞42
                

字符串有一個特殊的語法，允許嵌入式賦值，這個賦值不僅僅局限于簡單的變量替換，它是一個完整的賦值，如：

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!"
                

可以使用單引號將字符串引起來避免這種賦值，注意是單引號，不是雙引號，如：

irb(main):031:0＞ 'The answer is #{x}!'
                =＞ "The answer is \#{x}!"
                

數(shù)組

Ruby中的數(shù)組與.NET 1.0中的ArrayList類很接近，它們的大小都是可變的，用于存儲任意類型的數(shù)據(jù)，從0開始編號，如：

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
                

前面的代碼顯示了如何使用<<操作符向數(shù)組末尾追加項目，以及獲取或設(shè)置值使用的指針操作符[]，當你向數(shù)組末尾添加一個項目時，Ruby使用零值填充數(shù)組中的“洞”，當你訪問數(shù)組外的值時，Ruby返回零值而不是異常。

你可以使用一個范圍的指針將數(shù)組分片，也可以使用負的指針從后向前訪問數(shù)組，-1就是最后一項，-2是倒數(shù)第二項，以此類推，但不能使用反向范圍獲取反向分片，你可以使用一個正向范圍，然后調(diào)用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]
                

和字符串一樣，你會發(fā)現(xiàn)有多個唯一對數(shù)組有用的類函數(shù)，如：

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的最后一個核心數(shù)據(jù)結(jié)構(gòu)是散列，與.NET 1.0中的散列表類似，它是一個聯(lián)合數(shù)組，它的鍵值可以是任意類型的值，它們指向的數(shù)據(jù)也可以是任意類型的數(shù)據(jù)，實際上，大部分散列使用的是符號作為鍵值。

使用{}語法聲明散列，并且使用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中的變量和類函數(shù)名都是以小寫字母開頭的，可以包括字母、數(shù)字和下劃線。本地變量沒有前綴，實例變量以@開頭，全局變量以$開頭。
在使用變量前無需聲明，未初始化的變量有一個零值，下面是幾個預定義的變量：

nil表示一個“無”對象，與.NET中的null類似，除了nil是一個實例化的NilClass類外。

true和false分別是實例化的TrueClass和FalseClass。

在類函數(shù)中使用時，self指向調(diào)用類函數(shù)的對象實例；在一個類中使用時，它指的是實例化的類對象本身。

__FILE__ 和__LINE__返回當前執(zhí)行文件和那個文件中的行號。

符號

Ruby有一個特殊類型的字符串，叫做符號，因為字符串在Ruby中是可以被修改的，使用它們作為散列鍵是很慢的，而且有一些情況是不能預測的。
除了它們是以冒號（:）開頭外，符號的命名規(guī)則和變量的命名規(guī)則一致，你不能改變符號的值，兩個名字相同的符號它們的身份就一樣，它們可以作為優(yōu)秀的散列鍵，查找請求只需要比較整數(shù)值，而不是與一個可變長字符串的值進行對比。

類

Ruby中的所有事物都是對象，所有對象都是類的實例，為了探索類是個什么東西，在它上面調(diào)用類函數(shù)：

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中的事件處理程序類似，但當你想處理它們時還是必須要定義完整的類函數(shù)來連接這些事件，這就導致需要創(chuàng)建大量的類函數(shù)，因為框架需要它。

.NET 2.0引入了匿名委派的概念，它們起的作用與Ruby中的塊類似，如：

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中塊的語法是相當簡潔的：通常使用一對大括號打開塊和關(guān)閉塊，使用|x,y|語法標出傳遞給塊的變量。

Ruby中的塊和閉包類似，正如.NET 2.0中的匿名委派，這意味著它們有權(quán)訪問它們封裝作用域的值，即使那個作用域退出后也可以訪問。下面是一個將幾個值相乘的閉包示例：

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>

函數(shù)

Ruby中函數(shù)的定義比.NET簡單多了，因為不需要指定類型，如：

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執(zhí)行的某些東西叫做“鴨式輸入”：如果它走起路來像鴨子或聲音也像鴨子，那它一定就是鴨子。你不用問它“你是一只鴨子嗎？”，你只需要將它當做鴨子對它呷呷地叫就可以了，如果你渴望成為一只鴨子，只要你能呷呷地叫的就可以加入這個party。

注意greet函數(shù)定義時沒有對對象的類型做任何限制，因為它只打印它們—Ruby中任何事物都是支持打印的，這得益于to_s類函數(shù)的優(yōu)點，它可以將任何對象轉(zhuǎn)換成字符串，最終結(jié)果就是你可以greet它們。

下面是另一個例子：

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函數(shù)做的事情更多了：它調(diào)用了length函數(shù)。因此傳遞給print_len的是length函數(shù)的返回值，可以傳遞一個字符串或一個數(shù)組，因為它們都有對應(yīng)的length函數(shù)，但是不能傳遞一個數(shù)字，因為沒有對應(yīng)數(shù)字的length函數(shù)。

為了在.NET中編寫一個類似的函數(shù)，你可能需要創(chuàng)建一個IHaveLength接口作為你的參數(shù)類型，由于在你創(chuàng)建接口前類就已經(jīng)創(chuàng)建好了，所以不幸的是，可能你需要創(chuàng)建一個類型轉(zhuǎn)換器。

從另一方面來看，至少你已經(jīng)有了IHaveLength，并且知道函數(shù)需要什么東西，既然類型擔當?shù)氖悄撤N格式文檔的角色，在動態(tài)語言中你需要一個取舍，這樣你會在編寫文檔和單元測試時更自信，可以幫助你識別類或函數(shù)是如何使用的。

Ruby支持默認的參數(shù)值，如：

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前面沒有return，除非你明確地告訴它返回什么值，否則Ruby中的函數(shù)總是返回最后一個賦值，因此就不需要return關(guān)鍵字了。

Ruby支持變量參數(shù)，如：

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將變量參數(shù)打包成一個數(shù)組，然后你就可以訪問傳遞來的值，并且可以將它們集合到一塊兒。

函數(shù)和變量命名約定

Ruby中的函數(shù)以小寫字母開頭，可以包含字母，數(shù)字和下劃線。改變基礎(chǔ)對象的函數(shù)名稱以一個驚嘆號（!）結(jié)束，例如：upcase函數(shù)返回字符串的大寫，但是還單獨保留了原始字符串；相反，upcase!函數(shù)就真實地改變了基礎(chǔ)字符串。
回答問題（返回布爾值）的函數(shù)名稱以一個問號（?）結(jié)束。

類

類是來自新對象實例創(chuàng)建時的模板，例如：為了將前面的greet函數(shù)放入一個類，你可能要編寫以下代碼：

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)建了一個新的類，叫做Manners，并將函數(shù)greet添加到該類中了，最后，它創(chuàng)建了一個Manners類的實例，使用它greet Reader。

你可能認為在Ruby中類是對象的活動模板，與.NET中的類不同，Ruby中的類是編譯時定義的，你可以對其進行任意擴展，當你完成擴展后，類的現(xiàn)有實例也會立即得到新的反應(yīng)，注意當你嘗試告訴它farewell時會發(fā)生什么，如：

irb(main):008:0＞ m.farewell "Reader" NoMethodError: undefined method 'farewell' for #＜Manners:0x404839c＞ from (irb):8

當你嘗試調(diào)用farewell時，系統(tǒng)會告訴你它不知道這是什么，那么就可以對Manners類進行擴展，讓它知道這么說拜拜，如：

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類后，它的已有實例就會立即獲得這個新的功能。

Manners類有兩個函數(shù)，兩個都需要你的名字，你可能需要重新編寫它以便你創(chuàng)建它時可以傳遞名字給它，Ruby調(diào)用initialize函數(shù)，你傳遞的所有參數(shù)都傳遞給new，下面是更新后的Manners類：

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,>