Rock Say Ruby

Ruby User's Guide::Inheritance

2007-06-11T19:38:00.000-07:00

繼承

English version: Inheritance

我們日常的個體分類系統是自然地階級分層。我們認知所有的貓都是哺乳動物，所有的哺乳動物都是動物。較小的類別繼承了具有分類歸屬關係之較大類別的特性。如果哺乳動物會呼吸，則貓就會呼吸。此一概念在 Ruby 中的表達方式如下例:

雖然我們未曾具體描述貓應該如何呼吸，但由於貓被定義為哺乳動物的子類別，故每一隻貓仍將繼承哺乳動物類的行為特徵。在個體導向的術語中，較小的類別稱為子類別(subclass)或衍生類別(derived class)，較大的類別稱為父類別(superclass)或基礎類別(base class)。因此從程序員的觀點看，貓自然會擁有呼吸的能力。在我們添加發聲方法之後，我們的貓就能呼吸與發聲。

譯注: tama 即「玉(たま)」的日文發音，日本人常常替小貓取這個名字。

有時候，特殊的子類別不能繼承父類別的某些行為特徵。舉例而言，一般的鳥類都會飛翔，但企鵝卻是一種不會飛的鳥類。在個體導向的術語中，我們稱這種情形是行為的特化或偏化。(譯注: 參考《PHP 的參照及唯讀參照之實作》。雖然是 PHP 的文章，但其中的實踐內容非常適合說明繼承原則的特化與返祖化問題。)

我們不需要鉅細靡遺地定義每一個新類別的每一個行為特徵，僅需要增加或重定義子類別與父類別不同之處即可。這是繼承原則為個體導向編程所帶來的好處之一。

Ruby User's Guide::Classes

2007-04-17T01:18:00.000-07:00

類別

English version: Classes

真實世界是由一個個獨立個體所構成，我們將這些獨立個體按其屬性、行為抽象化地分門別類，於是有了各種類(classes)。例如，當一名很小的小孩子看到一隻狗時，可能會說 "汪汪" ，而不關心它的品種。我們很自然地以分類方式看待天地萬物。

在個體導向編程技術中，個體的種類，如「狗」，稱之為「類(class)」。歸屬於某一類的個體則稱為該類的實例(instance)。

在 Ruby 或任何個體導向語言中，要建置一個體時，首先要定義類的特徵，然後建立一個實例。下例闡明此過程，首先定義一個簡單的 Dog 類。

在 Ruby 的關鍵字 class 與 end 之中的程式碼，即為類的定義內容。在此範圍中的 def 定義了類別的方法 — 如前章如述，即對應於此類個體的具體行為。

我們已經定義了 Dog 類，接著可以建立一個 dog (在 Ruby 的語言慣例中，首字母大寫者表示「類」，小寫表示類別的實例):

我們做了一個 Dog 類的新實例，並命令為 pochi 。每個類別的方法 new 可建立該類別的一個實例。因為 pochi 是 Dog ，根據我們的類別定義，它將具有我們賦予 Dog 類的一切特性。由於我們的想法非常簡單，在此我們僅能要求 pochi 玩一種把戲。

建立某類的一個實例又稱為類別實例化、具現化。我們需要有生命、有實體的狗，才能交談；我們不能要求狗類此一概念可以咆叫。

另一方面，如果我們想要聽見一隻狗的叫聲而不在乎那條狗的存在，我們可以創造一隻暫時性的狗，讓它發出聲音後就消失。

你可能會說: "等等，這可憐的傢伙在咆叫之後就會消失？" 是的，如果我們懶得給它名字， Ruby 的自動垃圾收集功能將判定這是一隻不再需要的流浪狗，並無情地處理掉。這是好事，如此我們才能無後顧之憂地建立我們需要的每一隻狗。

Ruby User's Guide::Methods

2007-03-21T00:44:00.000-07:00

方法

English version: Methods

什麼是方法(method)? 在個體導向編程中，我們不希望外部直接操作個體內的資料；因為個體本身更了解這些資料應如何操作，故透過它提供的方式操作資料較為合適。這麼想吧，我們傳一些訊息給個體，這些訊息將引起個體做出某些動作或有意義的回應。我們只需知道傳什麼訊息可以讓個體做哪些工作，而不需關心個體內部的實際工作內容。那些允許我們要求個體完成或處理訊息的工作，就稱之為個體的方法或行為。「方法」或「行為」這兩種詞彙皆有使用。

在 Ruby 中，我們以句號 (.) 調用個體的方法。個體為主詞置於句號左側，方法為動詞置於句號右側。 Ruby 是在程式運行途中，依變數當前所指涉之個體決定如何調用方法回應訊息。

直覺可知這是在問此字串個體之長度為何。技術上，我們調用 "abcdef" 之個體方法 length。

其他個體對「長度」的詮譯可能有些許差異，或者完全不同。

長度的意義根據我們所談及的對象不同而有所差異。我們第一次問 foo 之長度時，它指涉一個字串，故長度的意義為此字串的字元數。第二次問長度時，foo指涉一個陣列，在大多數情形下，此時長度的意義是指陣列的內容數量，故答案為 2 。

根據實際指涉之個體以及傳遞之訊息決定工作方法的方式，接近我們使用自然語言時的表達習慣：同一詞語會依對象不同而具有不同的意義。此為個體導向編程的特徵，我們將之稱為「多型(polymorphism)」。

當個體接收到一個它無法理解的訊息時，將喚起(raised)錯誤:

故我們需要知道個體接受哪些方法，雖然我們不須知道這些方法如何工作。

若方法需要引數(arguments)時，引數通常用小括弧包起，但可以也省略。

Ruby 有一個特殊變數稱為 self，它指涉發生行為之個體。因為我們經常使用 "self."，所以在個體本身內部使用時，我們可以省略它。

傳統上的函數呼叫(function call)在 Ruby 中亦被視為方法調用。那些函數性的方法仍然具有類似傳統程式語言的函數之行為特徵。在 Ruby 中談到「函數」時，通常表示那些並非真正的個體方法，而是純粹的演算法或抽象的敘述。

Ruby Programming Wikibook::Symbol

2007-03-11T21:16:00.000-07:00

符號(Symbol)

將冒號(:)加在識別字前，即為符號。符號是一種識別用的記號，經常於雜湊表中作為鍵值。可用%s指定冒號之替用符號。

範例:

:abc    # just mark here as 'abc'
t1 = {:name => 'john', :age => 20}
puts t1[:name]
t2 = {%s'name' => 'smith', %s[age] => 16}
puts t2[:name]

一般而言，以符號作為雜湊表之鍵值時效能較佳。因為以字串為鍵值時，Ruby 必須計算字串的雜湊值；以符號為鍵值時則不需計算。熟悉 C/C++ 語言的程式員可以 enum 與 map 之差異比對：以符號為鍵值類似以 enum 建立表；以字串為鍵值類似以 map class 建立表。兩者效能差異顯著。

Ruby Programming Wikibook::Variables and Constants

2007-03-11T21:09:00.000-07:00

在 Ruby 中，我們可以識別字為一個變數命名，名稱沒有長度限制。一個尚未初始之變數，其值為nil。

區域變數(Local Variable)

範例:

foobar

一個變數之名稱若以小寫英文字母 (a-z) 或底線字元 (_) 為首，則該變數即為域變數或方法之參數。區域變數只能在它初始化之區塊內存取。例如:

i0 = 1
loop {
i1 = 2
print defined?(i0), "\n"      # true; 已定義，"i0" 於上層區塊中初始化。
print defined?(i1), "\n"      # true; 已定義，"i1" 於此區塊中初始化。
break
}
print defined?(i0), "\n"        # true; 已定義，"i0 於此區塊中初始化。
print defined?(i1), "\n"        # false; 未定義，"i1" 於 loop 區塊中初始化。

實例變數(Instance Variable)

範例:

@foobar

一個變數之名稱若以 '@' 為首，即為實例本身的實例變數。實例變數屬於實例之一部份，其意義等於 C++/Java 語言中之私有資料成員(private data member)。事實上，Ruby 嚴格遵守一個變數只能在其初始化區塊中存取之定義，因此區塊以外之敘述不允許存取實例內之變數。若外部想存取實例變數，只能透過實例的方法。

類別變數(Class Variable)

範例:

@@foobar

類在 Ruby 中也是一個實在的個體，因此類本身也有內部的變數。其意義等於C++/Java語言中之類別私有靜態成員(private static class member)。

全域變數(Global Variable)

一個變數之名稱若以 '$' 為首，即屬全域變數；當程式運作時，可在任何地方存取它。範例:

$foobar

常數(Constant)

範例:

FOOBAR

一個變數之名稱若以大寫英文字母 (A-Z) 為首，即為常數。Ruby 允許在初始化常數後又再次指派其他值，但會發出警告訊息。Ruby 的每個類都是一個常數。

若試圖取得一個未初始常數之值，將會喚起一個NameError異常。

虛設變數(Pseudo Variable)

虛設變數具有變數的性質，但其意義固定，由 Ruby 按其意義決定虛設變數指涉的內容。若改變虛設變數之意義，將令 Ruby 發出異常。

self

指涉行為個體本身。和 C/C++ 語言之 this 關鍵字意義相同。

nil

表示「無此物」，這是 NilClass 類別的唯一實例。

true

「真」或「真值」，為 TrueClass 類別之唯一實例。

false

「偽」或「偽值」，為 FalseClass 類別的唯一實例。 (在 Ruby 中，nil 也視同 false，除此以外任何值都視同 true。)

Ruby Programming Wikibook::Alternate Notation

2007-03-08T17:32:00.000-08:00

Alternate Notation

'%'記號

Ruby 正式語法使用單引號與雙引號作為字串的括號。但 Ruby 從 Perl 語言中得到一個關於字串括號的古怪靈感：用 % (百分比字元) 指定字串的括號符號。例如: %[], %(), %{} 。除成對括弧符號外也可用單獨字元，如 %!!, %@@ 。在一個 % 字元後得指定一個修飾字元，諸如: %q[], %Q[], %x ，它們決定是否套用反斜線記號與竄寫規則。詳見單引號的替用者與雙引號的替用者。

範例:

 '不套用竄寫與反斜線記號規則'
"套用竄寫 #{interpolation}, 與反斜線記號 - \n"
%q(不套用竄寫)
%Q(套用竄寫 #{interpolation} 與反斜線記號 - \n)
%(竄寫與反斜線)
`echo "指令竄寫與反斜線"`
%x(echo "指令竄寫與反斜線")

上述所有例子都有建置一個字串變數之效果。

當我們需要建置一個含有括號字串的字串卻又不想使用反斜線記號為括號字串轉義時，便經常運用'%'記號自行指定字串括號之符號。以自行指定的符號作為括號的替用者。

 "string \"with\" quotes"    #字串中含有雙引號(")，必須以反斜線記號轉義
%{string "with" quotes}     #以'%'記號指定大括弧{}為替用括號。
%!another string example!         => "another string example"
%@another "obnoxious" example@    => "another \"obnoxious\" example"

'%r' 可指定字樣規則式之邊界符號(/ 字元)的替用者。例如下列二式同義:

 response.gsub! /<.*?>/, ""    # 移除所有標籤
response.gsub! %r{<.*?>}, ""  # 以 %r 指定大括弧為 / 符號的替用者。

'%w' 可指定陣列之邊界符號([ ])的替用者。還有一個附帶效果：將其中所有字面值都視為字串；單、雙引號將被視為字串的一部份而非字串的括號。

範例:

ar = ['123', 'abc', 'xyz']
=> ["123", "abc", "xyz"]
ar = %w<>
=> ["123", "abc", "xyz"]
ar = %w! 123, abc, xyz !
=> ["123", "abc", "xyz"]

ar = ['I\'s']
=> ["I's"]
ar = %w[ I's ]
=> ["I's"]

%記號修飾字元與效果表

%	指定字串括號的替用符號，並套用雙引號括號規則。詳見雙引號的替用者。
%q	指定字串括號的替用符號，並套用單引號括號規則。詳見單引號的替用者。
%Q	指定字串括號的替用符號，並套用雙引號括號規則。詳見雙引號的替用者。
%r	指定字樣規則式之邊界符號(/ 字元)的替用符號。
%s	指定符號之邊界符號(:)的替用符號。
%w	指定陣列之邊界符號([ ])的替用符號。
%W	指定陣列之邊界符號([ ])的替用符號，並套用雙引號括號規則。
%x	指定指令竄寫之邊界符號(`)的替用符號。

Ruby User's Guide::Iterators

2007-03-03T11:03:00.000-08:00

迭代

English version: Iterators

迭代(iterator)並非 Ruby 原創的概念，這是普遍存在於個體導向語言中的概念。 Lisp 也有，儘管 Lisp 不以迭代稱呼。然而在這些語言中，迭代並非可以一概之的相似性概念，所以它仍需要仔細說明。

英文動詞 iterate 意為做相同的事多次 (中文直接用「反覆」) ，所以 迭代(iterator) 指一種會反覆做相同工作的事物。

撰寫程式碼時，常有各式各樣的情形需要循環處理。在 C 語言中，我們用 for 或 while。例如:

C 語言的 for(...) 語法幫助我們建立抽象的迴圈動作，但仍要求程序員了解字串內部結構的細節，才能寫出測試 *str 是否為 null 字元的程式碼。這使得 C 語言感覺像是低階語言。高階語言應提供更有彈性的迭代。看看下列的 sh 指令手稿的做法:

目前目錄下所有 C 語言源碼及標頭檔案都會被處理，由命令外層負責一一取得檔案名稱。這種作法看來比 C 語言高階多了，不是嗎？

但還有需要考量之事: 程式語言能否為我們自定的資料型態提供如同內建資料型態一般的迭代方式？個體導向編程 (OOP) 時，我們時常定義一個又一個的資料型態，所以須認真對待這問題。

為達上述目的，每種個體導向程式語言各有一些方便進行迭代的能力。有些語言為此目的提供了特殊的類別； Ruby 則允許我們直接定義迭代內容。

Ruby 的 String(字串) 型態有些實用的迭代:

each_byte 是處理字串中每一個字元的迭代。每個字元都會被代入區域變數 c 。若以類似 C 語言的程式碼來表達，可改寫成...

... 然而， each_byte 迭代之概念較簡單，即使未來大幅改變 String 類別的結構，似乎仍可繼續運作。迭代的其中一項好處在其有助於對此類變化設計耐用的程式碼；一般而言確實是良好的程式編寫特性。

另一個有用的 String 迭代是 each_line。

用迭代比在 C 語言中做同樣的事要容易得多。

在前一章說明的 for 敘述就是使用 each 迭代完成迭代工作。 String 的 each 與 each_line 的效果相同，所以上述範例可以 for 改寫為:

我們可以在迴圈中結合 retry 敘述令迴圈重新開始工作。

將上述範例中的 retry 換成 redo ，只會令迴圈再做一次現行迭代項目，其輸出內容為:

yield 有時用於定義一個迭代內容。 yield 可將程式流程轉移至傳遞給迭代的程式碼區塊 (這在程序個體一章中會仔細說明)。下列範例定義了名為 repeat 的迭代，它會依據引數所指定之次數，重複執行程式碼區塊內容。

利用 retry ，我們可定義一個類似 Ruby 標準 while 效果的迭代。

你現在是否了解什麼是迭代了呢？儘管有些限制，但你已經可撰寫自創的迭代；事實上，每當定義一個新的資料型態時，通常會一併定義合適的迭代作為搭配。以此而言，則上述範例並無用處。先在此打住，當我們更了解什麼是類別時，我們再談如何設計實用性的迭代。

Ruby User's Guide::Control structures

2007-02-28T06:12:00.000-08:00

流程控制

English version: Control structures

本章說明關於 Ruby 的流程控制敘述。

`case`

我們使用 case 敘述測試一連串的條件。其作用類似 C 和 Java 之中的 switch ，但使用方式更強大。

2..5 是表示 範圍(range) 的式子，此例指示在 2 到 5 以內的範圍。如下列算式便可測試 i 的值是否處於 2 到 5 以內之範圍:

case 內部使用運算子 === 一次測試多個條件式。基於 Ruby 的個體導向本性，出現在 when 條件中的個體會套用 === 運算，作用如同 (6..10) === i。

在下面的例子中，將會測試字串是否等於第一個 when 中的字串，接著測試是否符合第二個 when 的字樣規則式。

`while`

Ruby 提供了常見的迴圈結構。然而你將在下一章中學會如何使用 迭代(iterator) ，它讓你不需要時常撰寫迴圈程式碼。

一個 while 敘述就是一個重複的 if 敘述。我們在前面幾章的猜謎程式及字樣規則程式中曾使用它；它的句型為 while condition ... end ，其中包含當 condition 為真時就重複執行的程式碼區塊。但 while 和 if 也可以簡單地用於單獨的敘述:

有時候你需要否定一個測試條件。unless 就是 if 的否定型，而 until 就是 while 的否定型。你可以自己試試看。

有四種在迴圈內部中斷迴圈進行的方式。第一種、break，它的意義是脫離迴圈。第二種、next ，它的意義是跳到迴圈起始處繼續下一個迭代工作項目 (如同 C 的 continue)。第三種、redo ，它將重新開始現行的迭代工作項目。下列以 C 程式碼表現 Ruby 中的 break, next, 和 redo 之作用:

第四種離開迴圈的方式是 return 。它不只是脫離迴圈，也會脫離包含這迴圈的方法(method)。如果給它一個引數，該引數將視為方法的回傳值，而不是傳回 nil 。

`for`

Ruby 的 for 可提供與 C 的 for 相同的功用，但更有彈性。迴圈可以自行從一個聚合體(colection) - 如陣列、雜湊表、連續數值範圍等等 - 提取一個元素執行，而不需程序員指示它怎麼做:

聚合體也可以是一個數值範圍，這用法便是多數人所說的 for 迴圈用法:

此例示範如何從頭到尾一一處理陣列元素:

最後我們稍微超前進度，先預習一下迭代運算的內容。for 其實就是迭代運算之 each 方法的另一種寫法。下列兩種句型之意義相等:

迭代運算通常可以取代傳統的迴圈，一般說來使用迭代會方便得多。下一章我們將學到更多關於它的內容。

Ruby User's Guide::Back to the simple examples

2007-02-25T07:30:00.000-08:00

回顧範例

English version: Back to the simple examples

現在，我們說明一些先前的範例程式碼。

下列是「simple examples」一節中出現的程式碼。

因為這是第一次解釋，我們一行行個別審視。

階乘 (Factorials)

第一行中， def 是定義一個函數 (或更明確地稱為 方法 (method) ；我們稍候會於方式 (methods) 一節中說明) 的敘述。此敘述具體指明了函數 fact 有一個被稱為 n 的引數 (argument) 。

敘述 if 用於條件判斷，此處之條件為 n 是否等於 0 。當條件成立時便運行下一段程式碼；否則運行諸如 else 之敘述後的程式碼。

當條件符合時， if 敘述之運行結果為 1 。

若條件不符合，則運行從 else 到 end 之間的程式碼。

當條件不符合時， if 敘述的運行結果為運算 n 乘以 fact(n-1) 。

第一個 end 結束 if 敘述。

第二個 end 結束 def 敘述。

以一個來自命令列的值作為引數調用我們的 fact() 函數，並印出結果。

ARGV 是一個容納了命令列引數的陣列。由於 ARGV 的成員是字串，我們必須用 to_i 將其轉換成一個整數。 Ruby 不會像 Perl 那樣自動轉換字串為整數。

當我們提供一個負數給這程式時會發生什麼事呢？你看出問題了嗎？可以修正它嗎？

字串 (Strings)

下一個解釋的範例是字串 (strings) 一節的猜謎程式。

在這程式中，使用了新的控制結構 while 。當指定的條件為真時，就會重複執行在 while 和其對應的 end 之間的程式碼。在此例中， guess = STDIN.gets 既是一個動作敘述 (收集使用者輸入的一行內容並儲存在 guess 變數中)，也是一個條件 (若 guess 沒有輸入內容，亦即算式 guess = STDIN.gets 之值為 nil時，則中止 while 迴圈)。

STDIN 是標準輸入設備。通常 guess = gets 和 guess = STDIN.gets 做的事一樣。

第2行的 rand(3) 傳回介於 0 到 2 之間的亂數。此亂數用於自陣列 words 中提取一個內容。

在第5行中，我們以方法 STDIN.gets 自標準輸入設備中讀取一行內容。遇到 EOF (檔案結束) 時， gets 傳回 nil 。故將此程式碼與 while 合起來可令其重複執行至遇到 ^D (在 DOS/Windows 下則用 ^Z 或 F6) 為止，意味著結束輸入。

第6行的 guess.chop! 刪去儲存在 guess 中的最後一個字元；因為 gets 會將使用者按下的 Return 儲存為一個 換行 (newline) 字元，但我們對換行字元不感興趣，故在此例中將會刪去該 換行 (newline) 字元。

第15行印出密語。我們寫下 puts (put string) 附帶2個引數的敘述，這將印出一個引數後接著印出下一個。這和將 secret 寫成 #{secret} 而變成單一引數的作法有相同效果，令它更清楚地表示有一個變數將運算，而非單純地逐字印出：

許多程序員覺得這麼做可以清楚地表達要輸出的內容：它建立了單一字串作為 puts 的一個引數。

我們現在應用這個想法作為標準的輸出敘述，但這次用 print 代替第 4 和 13 行的 puts 。它們是不一樣的。 print 精確地輸出提供給它的內容； puts 則會加上一個換行。在第 4 和 13 行使用 print 可令游標停留在下一格，而不會移動到下一行開頭。這可作為使用者輸入之提示用途。通常，下列 4 個輸出呼叫方式之結果相同：

有一件事你可能需要知道：有時文字視窗會用緩衝區控制個別字元的輸出速度，只有當它遇換行字元時才會輸出緩衝區的資料。所以當猜謎程式無法如預期般顯示輸入提示時，就是內容被放入緩衝區了。想確保這事不會發生，那麼你可用 flush 立即送出你要顯示的提示文字。它告訴標準輸出設備 (名為 STDOUT 的個體)："別等了；現在就顯示緩衝區的內容。"

字樣規則式 (Regular expressions)

最後我們要說明字樣規則式一節的範例。

第 6 行的 while 條件式硬性指定為 true ，故形成了一個無窮迴圈。然而我們在第 8 及 10 行放了 break 敘述可脫離迴圈。這兩個 break 敘述也示範了 "if 修飾片語" 的用法。 if 修飾片語表示只有條件成立時才會執行其左手邊的敘述。此一由右到左的演算邏輯並不常見，但它提供了更貼近日常用語的表達形式。由於它不需要 end 敘述，所以也帶來了敘述簡潔的優點。 if 修飾片語慣例上用於敘述需要加上條件判斷且條件式可以簡短地在一行中寫完的情況。

注意，這程式的使用介面和猜謎程式並不相同。它允許使用者在未輸入其他內容時按下 Return 鍵離開程式。故我們測試輸入字串是否為空的，而非是否不存在。

第 7 和 9 行中，我們用了 "非破壞性 (non-destructive)" 的 chop ；這同樣可使我們自 gets 得到一個不含換行字元的輸入內容。那與 "破壞性 (destructive)" 的 chop 有何不同呢？在 Ruby 中，我們按慣例會取 '!' 或 '?' 作為某些函數名稱的最後一字。 ! 又可唸成 "碰!" ，這可指示此函數可能具有破壞性，亦即它會改變它所接觸的個體之內容。 chop! 直接影響原本的字串，而 chop 則在不傷害原本內容之情形下給你一個刪減過的複製品。底下以實例示範兩者差異。

第 8 及 10 行顯示了另一個方法命名慣例。一個問號 (?) 指示這是一個邏輯斷言方法，只回傳 true 或 false。

第 11 行根據使用者輸入的字串內容建立了一個字樣規則式。真正的工作則於第 12 行中完成，它用 gsub 全面性地將 ANSI 標記置入符合樣式的文字內容前後。

我們可以把第 12 行拆成：

或者用 "破壞性" 作風：

再次看看第 12 行的最後一部份。 st 和 en 是被定義在第 1-2 行 ANSI 的控制碼組合，這可讓文字改變顯示顏色。第 12 行中用 #{} 將這兩個變數之值嵌入字串中。兩者間的 \\& 則是一個技巧性用法。因為這個字串是以雙引號括起的，所以其中的一對斜線字元會被替換成單一個斜線字元，故 gsub 實際看到的是 \& 。這可令 gsub 將符合字樣的文字內容置換於此，所以就可以顯示用高亮度色彩標示符合字樣內容的字串了。

Ruby User's Guide::Arrays

2007-02-24T02:39:00.000-08:00

陣列 (Arrays)

English version: Arrays

你可以用方括號 ([ ]) 建立一個陣列，並在其中以逗號分隔列出各個細項。 Ruby 的陣列可以容納各式各樣的個體。

陣列就像字串一樣可以連接也可以重複。

我們可以用數字作為索引，提取陣列的任何一部份。

(負號指示自陣列尾端取偏移量而非從陣列開頭。)

陣列可用 join 轉成字串，字串也用 split 轉成陣列：

雜湊表 (Hashes)

有種稱為「關聯索引陣列 (associative array)」的特殊陣列，它不是用有序的數字索引提取內容，而是用無序的關鍵字(keys)。這種陣列有時又稱之為 雜湊表 (hash) 或 字典 (dictionary) ；在 Ruby 的世界中，我們慣用 雜湊表 一詞。我們可以用一對大括號 ({ }) 括起各對細項 (關鍵字 => 內容) 以建立雜湊表。在編程時，用雜湊表的時機將比用陣列的時機要多。

Ruby User's Guide::Regular expressions

2007-02-21T06:39:00.000-08:00

字樣規則式 (Regular expressions)

English version: Regular expressions

讓我們一起開始更有趣的程式吧。這次我們測試一個字串是否符合一個簡明扼要的樣式 (pattern) 。

在樣式中有一些字元和字元組合具有特殊用意，包含下列：

`[]`	指定範圍 (例如： `[a-z]` 表示一個在 `a` 到 `z` 範圍內的字母)
`\w`	字母或十進位數之字元；與 `[0-9A-Za-z]` 相同
`\W`	非字母與十進位數之字元
`\s`	空白字元；與 `[ \t\n\r\f]` 相同
`\S`	非空白字元
`\d`	十進位數之字元；與 `[0-9]` 相同
`\D`	非十進位數之字元
`\b`	退格 (0x08) (若用於指定範圍時)
`\b`	單字邊界 (若不用於指定範圍時)
`\B`	非單字邊界
`*`	零到數個其前一符號的內容。
`+`	一到數個其前一符號的內容
`{m,n}`	最少 m 個且最多 n 個其前一符號的內容
`?`	零到一個其前一符號的內容；與 `{0,1}` 相同
`\|`	符合 '\|' 之前一符號或後一符號的內容
`()`	分組

一般以 字樣規則式 (regular expressions) 稱呼使用這種奇妙字彙的樣式。 Ruby 和 Perl 一樣用斜線 (/) 包圍樣式內容而不是用引號。若你以前從未用過字樣規則式，它們或許看起來像任何東西但仍然有規律性。但你應明智地花一些時間熟悉它們。它們具有強大及有效率的表達能力。當你需要進行樣式比對、搜尋、或其他文字字串之操縱時，它們將省去許多令人頭痛的事 (和許多行程式碼)。

舉個例子，假設我們想要測試一個字串是否符合此一描述："以小寫 f 開始，緊跟著一個大寫字母；之後可能有一些廢話，只要其中沒有任何小寫字母。" 若你是個老練的 C 程序員，你腦海中或許已經寫下幾十行程式碼了，對吧？承認吧，你是在自找麻煩。在 Ruby 中，你只需要用這個字樣規則式 /^f[A-Z][^a-z]*$/ 就可以測試你的字串了。

那麼 "包含以角括號圈住的十六進位數字？" 又如何？沒問題。

儘管字樣規則式一眼看來像個謎語，你仍將很快地為了它所能節省的許多表達功夫而感到滿意。

此處是一個幫助你試驗字樣規則式的小程式。將它儲存為 regx.rb 並在命令列下鍵入 "ruby regx.rb" 起動它。

這程式要求輸入兩次，第一次要輸入一個字串，另一次要輸入一個字樣規則。這字串與字樣規則進行比對測試，然後以高亮度反白顯示所有匹配的部份。現在先別管細節，這程式碼的分析工作很快就會做了。

str> foobar
pat> ^fo+
foobar
~~~

讓我們嘗試輸入一些東西吧。

str> abc012dbcd555
pat> \d
abc012dbcd555
   ~~~    ~~~

若你感到訝異，參考上面的表格： \d 與字元 d 無關，但符合一個十進位數字。

若有一個以上的結果符合樣式呢？

str> foozboozer
pat> f.*z
foozboozer
~~~~~~~~

foozbooz 將符合而不是 fooz ，因為字樣規則會配對符合字樣的最長字串。

此為一解析以冒號區隔時間欄位的字串的樣式。

str> Wed Feb  7 08:58:04 JST 1996
pat> [0-9]+:[0-9]+(:[0-9]+)?
Wed Feb  7 08:58:04 JST 1996
           ~~~~~~~~

"=~" 是關於字樣規則比對的運算符號；它回傳符合樣式之字串內容的位置，若無符合者則回傳 nil。

Ruby User's Guide::Strings

2007-02-21T05:33:00.000-08:00

字串 (Strings)

English version: Strings

Ruby 可以像數值資料般妥善處理字串。字串是一個被雙引號 ("...") 或單引號 ('...') 括起的內容。

雙引號和單引號在某些案例上具有不同的效果。由雙引號括起的字串允許添加一個引導的反斜線 (\) 在字元前轉換該字元之意義，也可以 #{} 嵌入一段賦值的式子。由單引號括起的字串不做這些解釋工作；你將得到你所看到的。例如：

Ruby 的字串處理方式很聰明也比 C 的方式更直覺。舉例來說，你可以用 + 連接多個字串，也可以用 * 重複一個字串內容數次：

在 C 中連接多個字串較此笨拙許多，因為 C 需要清楚的記憶體管理措施：

但用 Ruby ，我們不需要考慮字串佔用的記憶體空間。我們可以擺脫各種記憶體管理措施。

你可以對字串做這些事。

連接：

重複：

摘錄字元 (記下， Ruby 中的字元也是整數)：

(負號指示從字串尾端計算偏移位置，而不是從字串開頭)

摘錄部份字串：

內容測試：

現在，利用一些上述特性來設計一道猜謎程式。也許下列內容用 "猜謎" 這字眼太嚴肅了 ;-)

現在還不需要煩惱這些程式碼的細節。這猜謎程式跑起來會像這樣：

% ruby guess.rb
guess? foobar
Sorry, you lose.
guess? quux
Sorry, you lose.
guess? ^D
The word was baz.

Ruby User's Guide::Simple examples

2007-02-20T00:28:00.000-08:00

簡單範例

English version: Simple examples

我們來撰寫一個階乘計算函數。 n 階乘的數學定義是：

n! = 1              (when n==0)
   = n * (n-1)!     (otherwise)

這用 ruby 寫成：

你或許注意到 end 重複出現了。因為此一特徵， Ruby 被稱之為 ALGOL 式語言。 (事實上， ruby 的語法更像在模仿名為 Eiffel 的語言。) 你也許注意到少了 return 敘述。因為一個 ruby 函數會回傳最後一個計算結果，所以可省略 return 。此處可允許使用 return 敘述但非必要。

接著試試我們的階乘函數。加上一行程式碼可令我們得到一個可做事的程式：

此處的 ARGV 是一個含有命令列引數的陣列，而 to_i 將字元字串轉換成一個整數。

它可以接受引數為 40 嗎？這可能令此計算溢位...

它能做。 Ruby 甚至可能處理任何整數，只要你的機器有足夠的記憶體。所以 400! 也可計算：

我們無法一眼看出這是否正確，但它一定是正確的。 :-)

輸入與計算迴圈

當你不加任何引數喚起 ruby 時，它將自標準輸入裝置讀取命令，並在結束輸入之後執行這些命令：

上述的 ^D 即鍵入 control-D ，這在 Unix 中是表示結束輸入的慣用符號。在 DOS/Windows 中，改為按下 F6 或 ^Z 。

Ruby 也可執行一個稱為 eval.rb 的程式，這可讓你在互動式迴圈中從鍵盤輸入你的程式碼並顯示你的輸入結果。它會廣泛地出現在這入門書中。

If you have an ANSI-compliant terminal (this is almost certainly true if you are running some flavor of UNIX; under old versions of DOS you need to have installed ANSI.SYS or ANSI.COM; Windows XP, unfortunately, has now made this nearly impossible), you should use this enhanced eval.rb that adds visual indenting assistance, warning reports, and color highlighting. Otherwise, look in the sample subdirectory of the ruby distribution for the non-ANSI version that works on any terminal. Here is a short eval.rb session:

hello world 是 puts 的輸出內容。此例中的下一行報告最後的計算結果為 nil； Ruby 不會區別 敘述 (statements) 和 算式 (expressions) ，所以計算一段程式碼基本上意味視為相同事物執行。此處的 nil 指出 puts 並未回傳有意義的值。注意，我們可以鍵入 exit 或 ^D 離開這個直譯迴圈。

在本入門中， "ruby>" 就是我們的小程式 eval.rb 之輸入提示符號。

To Ruby From PHP

2007-02-19T11:09:00.000-08:00

To Ruby From PHP 之內容因為和 PHP 相關，所以我發佈在 To Ruby From PHP, 中譯。

Ruby User's Guide::Getting started

2007-02-19T10:07:00.000-08:00

開始吧

Engilsh version: Getting started

首先，你會想檢查 ruby 是否已經安裝了。在命令提示 (此處以 "%" 為提示符號，所以別輸入 %) 下輸入：

% ruby -v

(-v 告知直譯器印出 ruby 的版本), 然後按下 Enter 鍵。若 ruby 已安裝，你將會看到如下之訊息：

% ruby -v
ruby 1.8.3 (2005-09-21) [i586-linux]

若 ruby 尚未安裝，你可詢問系統管理者安裝，或者你可以自己裝，因為 ruby 是自由軟體，其安裝與使用皆不受限制。

現在，開始玩 ruby 吧。你可以在命令列下用 -e 選項直接寫下 ruby 程式:

% ruby -e 'puts "hello world"'
hello world

照慣例，一個 ruby 程式可以儲存在一個檔案中。

% echo "puts 'hello world'" > hello.rb
% ruby hello.rb
hello world

在撰寫比這內容更充實的程式碼時，你將會採用一個文字編輯工具！

一些驚人地複雜且有用的小程式可以被塞在一道命令之中。例如下列這一個，它將目前工作目錄中所有 C 原始碼和標頭檔內的 foo 替代成 bar ，並將原始檔案名稱後添加 ".bak" 作為備份：

% ruby -i.bak -pe 'sub "foo", "bar"' *.[ch]

這程式之作用如同 UNIX cat 命令 (但比 cat 做的慢)：

% ruby -pe 0 file

Ruby User's Guide::What is ruby?

2007-02-19T09:47:00.000-08:00

什麼是 Ruby?

Engilsh version: What is ruby?

Ruby 是 "一個快速與易用於個體導向編程的直譯式手稿語言" -- 這是什麼意思?

直譯式手稿語言:

有能力直接調用作業系統呼叫
強大的字串操作與字樣規則式 (RegExp)
開發時之立即回應

快速與易用:

不需要變數宣告
變數不用指定類型
語法簡明一致
記憶體自動管理

個體導向編程:

每個事物都是個體
類別、方法、繼承等等
singleton methods
以模組實現 "混成 (mixin)" 功能
迭代與程式區塊

還有:

複精度整數
便利的例外處理程序
動態載入
支援線程作業

如果你對上述概念感到陌生，別緊張，讀下去。 Ruby 語言之真言是 快速與易用。