Ruby快速入門（30分鐘）

在本教學中，將探討使用Ruby開始程式設計所需的基本語法，以及如何在30分鐘內學習並使用Ruby程式設計語言。

註：如果您還尚未安裝Ruby開發環境，請存取環境設定頁面並按照說明安裝： /3/44/1514.html

Ruby歷史

Ruby被許多人認為是一種「新」程式設計語言，但實際上是由一個叫作Matz的開發人員於1994年發布的。 Matz自我描述是一個「語言極客」，也是Perl大粉絲。他對Ruby的想法是建立一種像Perl這樣靈活而強大的語言，但在其語法上更具表現力 - 甚至可以具有類似於英語那樣的可讀性。

Ruby在日本迅速成長，直到2000年，真的沒有關於除了日本語言以外的任何文件。所以如果想要學習Ruby，那得必須先學習日語。敏捷程式設計的先驅Dave Thomas被Ruby迷住，並決定建立Ruby的其它語言文件。

自Ruby有了英文開始，Ruby就開始在英語世界中增長，儘管緩慢。系統管理員變得流行，編寫維護和「貼上」指令碼 - 類似Perl的用法。從2000年到2005年美國的Ruby社群已達數百個。

在2004-2005年，一家名為37Signals的芝加哥公司聘請了一名年輕的開發人員來構建一個Web應用程式。公司給了他幾乎完全的執行自由; 他們只關心用戶端的設計和功能。當時主要的Web技術是Perl CGI，PHP，Java的JSP和Microsoft的ASP。但是他們都是有點痛苦，但DHH的大衛(DHH)選擇了自己的方向。他在Ruby中寫了這個應用程式。他依靠核心庫和少數庫的幫助下，同時自己建立了整個堆疊(或多或少)。37Signals在Web應用程式使用Ruby來編寫，這個專案今天被稱為Basecamp。

當建立了Basecamp，DHH就會從中提取出Web框架。這是一個非常不同的方法，從Java/Sun或.NET/Microsoft，Web框架都是從高處往下傳播。相反，Rails從現實世界中抽出來。它側重於常規組態，使常見問題更容易解決。

這種方法是一個很大的打擊，Rails自從以來一直推動了Ruby/Rails社群的發展。現在，在亞馬遜上有數十本書，全球近一百個會議，有成千上萬的人是Ruby/Rails開發人員。

如果你想學習Rails，需要先學習Ruby！現在就開始咯 …..

1. Ruby直譯器

Ruby是一種「解釋」的程式設計語言，它不能直接在處理器上執行，它的程式碼必須饋送到稱為「虛擬機器」或虛擬機器的中介軟體。虛擬機器的一方面是Ruby程式碼，另一方面則是作業系統和處理器。這種方法的好處是您可以編寫一次Ruby程式碼，就可以在許多不同的作業系統和硬體平台上執行了。

Ruby程式無法執行自己的程式，它需要載入虛擬機器。使用VM執行Ruby的方式有兩種：通過IRB和命令列。

從命令列執行Ruby程式碼

這是編寫Ruby程式碼的耐用方法，因為要將指令儲存到檔案中。該檔案可以備份，傳輸，新增到原始碼管理等。

一個Ruby程式碼檔案範例

這裡建立一個名稱為:first-ruby.rb的檔案，如下所示：

#!/usr/bin/ruby   
# filename : first-ruby.rb

class Sample
  def hello
    puts "Hello, World!"
  end
end

s = Sample.new
s.hello

那麼可以這樣執行程式：

當您執行ruby first-ruby.rb時，實際上正在載入ruby虛擬機器，然後再載入first-ruby.rb檔案中的程式碼。

從IRB執行Ruby程式碼

Ruby是第一批語言推廣所謂「REPL」：閱讀，評估，列印，迴圈的程式設計語言。想像它就像一個計算器 - 就像在每個完整的指令中，IRB執行這些指令並顯示結果。

IRB最好用作實驗的便箋簿。許多開發人員在編寫他們的「真實」程式時，一般都保持IRB視窗開啟，使用它來記住某個方法如何工作或用於偵錯某個程式碼塊。

要開啟IRB進行實驗，可通過開啟終端(Mac)或命令提示字元(Win)並開啟或輸入irb來啟動IRB。以Windows系統為例，如下所示 -

註：按 Ctrl + D 可退出 irb 模式。

2. Ruby變數

程式設計都是要建立抽象的程式碼來描述和處理資料，要建立抽象，必須要為在程式碼中分配名稱來表示事物。變數只不過是為資料建立一個名稱的一種方式。

建立和分配變數

在某些語言中，需要在為一個變數分配值之前宣告這個變數。當為變數分配值時，會自動建立Ruby變數。下面來試試一個例子：

a = 250表示建立一個名稱為a的變數，並將值250儲存到其中。

右邊優先

在英文表示式中，是從左到右閱讀，所以從左到右讀取程式碼是很自然的。但是當使用單個等於號(=)評估求值一個賦值時，Ruby實際上首先評估求值右側。舉個例子：

irb(main):010:0> b = 10 + 20
=> 30
irb(main):011:0> b
=> 30
irb(main):012:0>

上面範例中，首先對10 + 20進行評估求值，再將求值結果儲存到b變數中。

靈活輸入

Ruby的變數可以容納任何型別的資料，甚至可以更改其持有的資料型別。例如：

irb(main):012:0> c = 200
=> 200
irb(main):013:0> c = "Flexible Typing"
=> "Flexible Typing"
irb(main):014:0> c
=> "Flexible Typing"
irb(main):015:0> c = 0.0001
=> 0.0001
irb(main):016:0> c
=> 0.0001
irb(main):017:0>

第一次賦予c變數為一個200的整數值。第二次賦值是將c變數的值更改其為「Flexible Typing」。

命名變數

大多數Ruby變數(區域性變數)的命名都有一些由VM強制的要求。這些要求約定如下 -

始終以小寫字母開頭(允許下劃線，雖然不常見)
不能使用空格
不要包含特殊字元，如$，@和＆

除了那些虛擬機器的要求，Ruby開發者對變數名稱有幾個常見風格偏好：

使用蛇形大小寫，即：名稱中的每個字都是小寫字母，並用下劃線(_)連線
以其內容的含義命名，而不是其內容的型別
不使用縮寫

好的變數名的範例如下：count，total_products，students_in_class或first_lesson。

一些不好的Ruby變數名稱的幾個例子，如下所示：

studentsInClass – 使用駱駝案而不是蛇形大小寫，應該命名為：students_in_class
1st_lesson – 變數不能以數位開頭，應該命名為：first_lesson
students_array – 包括名稱的資料型別，應該命名為：students
sts – 不使用縮寫，應該命名為：students

練習

使用IRB儲存每個以下變數名稱的值。哪些名字是好的，哪些是是無效的Ruby變數名稱，哪些是有效的，哪些是Ruby不建議使用的風格？

time_machine
student_count_integer
homeworkAssignment
3_sections
top_ppl

3. 字串

在現實世界中，字串是將一個個字串聯起來的。程式設計中的字串與真實字串無關。

程式設計中的字串用於儲存字母和數位的集合。它可以是一個單一的字母，如「a」，或者像「hi」這樣一個單詞，或者「Hello my friends.」這樣的一段話。

編寫一個字串

Ruby字串被定義為一個引號(")，後跟零個或多個字母，數位或符號，後跟一個閉包引號(")。最短的字串稱為空字串：""。單個字串包含文字的段落甚至頁面也很常見。

子字串

通常使用字串，可從整個長字串提取出來的一部分 - 這提取出來的部分稱為子字串。在 irb 嘗試這些例子：

irb(main):017:0> string = "Ruby in 30 Minutes at tw511.com"
=> "Ruby in 30 Minutes at tw511.com"
irb(main):018:0> string[0..8]
=> "Ruby in 3"
irb(main):019:0> string[8..16]
=> "30 Minute"
irb(main):020:0> string[8..-1]
=> "30 Minutes at tw511.com"
irb(main):021:0> string[8..-2]
=> "30 Minutes at yiibai.co"
irb(main):022:0>

正號和負號的位置

字串中的字元每個都有一個位置編號，它們從零開始。所以對於字串中的開頭「Ru」，「R」位置編號為0，「u」所在的位置編號為1。

要在主字串中提取出一個子串，可指定提取的起始位置和結束位置。因此，上面的string[0..8]提取出位置從0至8的字母，也就是：「Ruby in 3」。

Ruby解釋負的位置從字串的末尾返回。所以在上面範例中，結尾的字串「com」的字母分別對應為「m」位於-1，「o」位於-2 和「c」位於-3 。

所以如果一個字母同時有正數和負數的位置，那麼應該使用哪個？建議使用正數，因為這樣它們更容易理解。但是，如果要基於字串末尾查詢東西(例如「該字串的最後一個字元是什麼？」)，則使用負數指定位置。

常用的字串方法

在IRB中使用字串(物件)中一些常用的方法。

.length

length方法用於求出字串中有多少個字元(包括空格)：

irb(main):022:0> string = "0123456789"
=> "0123456789"
irb(main):023:0> string.length
=> 10
irb(main):024:0> string = "maxsu"
=> "maxsu"
irb(main):025:0> string.length
=> 5
irb(main):026:0>

嘗試：計算你的名字的總長度

.split

有時想要將一個字串分成幾部分。例如，假設有一個儲存為字串的句子，並將其分解成單詞：

C:\Users\Administrator>irb
irb(main):001:0> string = "This is my sample sentence."
=> "This is my sample sentence."
irb(main):002:0> string.split
=> ["This", "is", "my", "sample", "sentence."]
irb(main):003:0>

.split方法返回一個陣列，這將在後面的部分講解中了解到。它預設使用空格(「」)字元將字串分割成多個部分。

.split使用引數

但有時要分割的不是一個帶有空格的字元。 .split方法接受一個引數來指定分隔符，看看下面範例就明白了。

irb(main):003:0> numbers = "1,2,3,4,5,6,7,8"
=> "1,2,3,4,5,6,7,8"
irb(main):004:0> numbers.split
=> ["1,2,3,4,5,6,7,8"]
irb(main):005:0> numbers.split(",")
=> ["1", "2", "3", "4", "5", "6", "7", "8"]
irb(main):006:0>

在第一次分割的呼叫中，它嘗試使用空格作為分隔符，但字串中沒有分隔符，所以得到一個整個字串的陣列。在第二次嘗試中，指定使用逗號(「,「)作為分隔符，所以得到一個8個數位值的陣列。

.sub 和 .gsub

這兩種方法可以用來替換字串的部分。它們就像在文書處理器中使用「查詢和替換」。 .sub替換只發生一次。而.gsub全域性替換的縮寫，替換所有的發生(如「全部替換」)。

對於.sub和.gsub，需要指定兩個引數：首先是要替換的子字串，然後再替換要替換的字串。

irb(main):013:0> greeting = "Hello, Hello Everyone!"
=> "Hello, Hello Everyone!"
irb(main):014:0> greeting.sub("Hello","Hi")
=> "Hi, Hello Everyone!"
irb(main):015:0> greeting.gsub("Hello","Hi")
=> "Hi, Hi Everyone!"
irb(main):016:0>

組合字串和變數

將變數的值與字串相結合這是在開發應用程式中最經常使用的。例如，現在從下面這個例子開始：

"Good morning, ?? !"

當把上面語句放入IRB時，它只是列印輸出同一個字串。如果編寫一個應用程式，希望它以使用者名而不是「??」來跟使用者打招呼，那麼需要怎麼做？

需要做的就是將變數與字串組合。有兩種方法可以做到這一點。

方法-1. 字串連線

第一種方法，可使用字串連線，它將字串與加號連線：

irb(main):021:0> name = "Maxsu"
=> "Maxsu"
irb(main):022:0> puts "Good morning, " + name + " ! "
Good morning, Maxsu !
=> nil
irb(main):023:0>

在第一行中，設定了一個name變數來儲存名稱。在第二行，列印字串「Good morning「並結合」name「變數和字串」!「的值。

方法-2. 字串插值

第二種方法是使用字串插值，將資料貼上到字串的中間。

字串插值僅適用於雙引號字串。在字串內使用插值標記#{}。在這些括號中可以把任何變數或Ruby程式碼放入其中，這些變數或Ruby程式碼將被評估求值，其結果轉換為一個字串，並輸出到外部字串的那個位置。上面的例子可以這樣重寫：

irb(main):023:0> name = "Maxsu"
=> "Maxsu"
irb(main):024:0> puts "Good morning, #{name}!"
Good morning, Maxsu!
=> nil
irb(main):025:0>

如果比較輸出結果，就會看到它們輸出的是完全相同的結果。內插樣式往往是輸入較少的字元型別，較少的雙引號開啟/關閉，所以可避免加雙引號時忘記書寫對稱(往往有輸入多一個，少一個的問題)。

內插插入程式碼

還可以將任何Ruby程式碼或計算表示式內建在括號內，如下所示：

irb(main):025:0> modifier = "very "
=> "very "
irb(main):026:0> mood = "excited"
=> "excited"
irb(main):028:0> puts "I am #{modifier * 3 + mood} for today's play!"
I am very very very excited for today's play!
=> nil
irb(main):029:0>

首先對#{modifier * 3 + mood}程式碼塊進行評估求值，然後將結果注入外部字串中。

4. 符號

符號有點難以解釋，它們是字串和數位的一半。但是可以很容易識別一個符號，因為它是以冒號開始一個或多個字母，如:flag或:best_friend。

新程式員的符號

如果你是程式設計的新手，可將一個符號看作是一個幾乎沒有任何方法和沒有字串插值的被剝離下來的字串。將正確的字串與類似符號的方法列表進行比較，如下所示：

2.1.1 :001> "hello".methods
2.1.1 :002> "hello".methods.count
2.1.1 :003> :hello.methods
2.1.1 :004> :hello.methods.count

有經驗的程式員的符號

如果你是一個有經驗的程式員，想象一個符號是一個「命名整數」。符號參照的實際值無關緊要。我們所關心的是，虛擬機器內對該值的任何參照將返回相同的值。因此，符號在全域性符號表中定義，它們的值不能改變。

5. 數位值

數位有兩種基本型別：整數(整數)和浮點數(有小數點)。
整數對於您和計算機來說都要容易一些。您可以使用包括+， - ，/和*在內的整數的正常數學運算。整數有一些方法可以用來做數學相關的事情，過呼叫5.methods方法就可看到一些常用的方法。

重複指令

重複執行指令在其他語言中的常見模式是for迴圈，用於重複執行某些指令一定次數。例如，在JavaScript中可以寫：

for(var i = 0; i < 5; i++){
  console.log("Hello, World");
}

對於迴圈是很常見的，但它們的程式碼不是很容易閱讀。因為Ruby的整數是它們擁有方法的物件。其中的一個方法：times是重複執行指令的方法。

以Ruby樣式重寫上述回圈：

5.times do
  puts "Hello, World!"
end

在這個例子中，使用times方法和具體的執行程式碼塊。在下一節中將討論塊。但是請先在IRB中執行這個例子，看看結果會是什麼。

6. 塊

塊是Ruby中經常使用的強大概念。可將塊視為一組捆綁在其他地方使用的指令的方式。

塊的開始和結束

在上一節中有一個使用.times方法的塊用整數表示：

5.times do
  puts "Hello, World!"
end

該塊以關鍵字do開始，以關鍵字end結束。 do/end風格總是可以被Ruby直譯器所接受的。

支架塊

當塊僅包含單個指令時，經常使用備用標記{和}來標識塊的開始和結束：

5.times{ puts "Hello, World!" }

塊被傳遞給方法

那麼使用塊來做什麼？塊可以用來作為傳遞給方法呼叫的引數。

例如，如果呼叫了5.times，Ruby就不會知道要執行五次了。當通過塊時，就會說「這裡是希望每次執行的說明」。

塊中有很多的方法。就像前面看到的.gsub方法一樣，字串早就為每個匹配執行一個塊：

irb(main):038:0> "this is a sentence".gsub("e"){ puts "Found an E!"}
Found an E!
Found an E!
Found an E!
=> "this is a sntnc"
irb(main):039:0>

請注意，」Found an E!「顯示了三次，因為字串中有三個E字母。

塊引數

通常，在塊內指示需要參照正在使用的值。當在編寫塊程式碼時，可以在管道字元中指定一個塊引數：

5.times do |i|
  puts "Hello, World! "
end

什麼值應該放入該塊引數，這取決於要呼叫的方法。在本範例中，times方法放入當前執行的數值。嘗試上面的塊，觀察輸出，然後嘗試這樣修改：

5.times do |i|
  puts "#{i}: Hello, World!"
end

上面程式碼輸出結果如下 -

irb(main):045:0> 5.times do |i|
irb(main):046:1*   puts "#{i}: Hello, World!"
irb(main):047:1> end
0: Hello, World!
1: Hello, World!
2: Hello, World!
3: Hello, World!
4: Hello, World!
=> 5
irb(main):048:0>

而.gsub在找到的字串中傳遞。嘗試這個(用括號表示法)：

irb(main):048:0> "this is a sentence".gsub("e"){|letter| letter.upcase}
=> "this is a sEntEncE"
irb(main):049:0>

在上面結果中看到gsub正在使用塊的結果作為原始匹配的替換。

7.陣列

通常當編寫程式時，我們需要處理資料的集合。先來看看最常見的資料集合 - 陣列。

視覺化模型

陣列是數位索引列表。想象一下，有一張空白的紙，畫了三個小盒子：

 ---  ---  ---
|   ||   ||   |
 ---  ---  ---

可以按照從左到右對每一個位置進行編號：

 ---  ---  ---
|   ||   ||   |
 ---  ---  ---
  0    1    2

然後在每個框中放入字串(或其它值)：

 -------------  ---------  ----------
| "Breakfast" || "Lunch" || "Dinner" |
 -------------  ---------  ----------
       0            1           2

現在變成一個有三元素的陣列。 Ruby陣列的大小可以增長和縮小，所以如果新增一個元素，它通常會在結束位置新增，索引值也會變遞增1：

 -------------  ---------  ----------  -----------
| "Breakfast" || "Lunch" || "Dinner" || "Dessert" |
 -------------  ---------  ----------  -----------
       0            1           2           3

請注意，最後一個元素的位置總是比元素的數量小1。

陣列中在索引為2位置對應的資料值為「Dinner」。最後一個元素對應的資料值為「Dessert」。

程式碼中的陣列

以下是Ruby程式碼中相同建模的方法：

irb(main):049:0> meals = ["Breakfast", "Lunch", "Dinner"]
=> ["Breakfast", "Lunch", "Dinner"]
irb(main):050:0> meals << "Dessert"
=> ["Breakfast", "Lunch", "Dinner", "Dessert"]
irb(main):051:0> meals[2]
=> "Dinner"
irb(main):052:0> meals.last
=> "Dessert"
irb(main):053:0>

在上面程式碼執行結果中，觀察到…

該陣列是通過將資料片段放在方括號([])之間並用逗號分隔來建立的。
通過使用「鏟子運算子」(<<)新增一個元素到陣列的末尾
通過使用方括號([])在指定索引位置來獲取元素
陣列中一些方便的方法，如.last

常用陣列方法

陣列有很多很酷的東西。以下是幾個例子：

.sort方法

sort方法將返回一個新的陣列，其中元素是已經被排序過了。如果元素是字串，它們將以字母順序返回。如果它們是數位，它們將按升值順序回來。嘗試下面範例：

irb(main):056:0> array1 = ["this", "is", "an", "array"]
=> ["this", "is", "an", "array"]
irb(main):057:0> array1.sort
=> ["an", "array", "is", "this"]
irb(main):058:0> array1
=> ["this", "is", "an", "array"]
irb(main):059:0>

可以使用sort方法重新排列元素的順序。使用each方法遍歷每個元素。使用join方法將它們一起混合成一個字串。使用index方法找到特定元素的地址。可以使用include?方法詢問陣列是否包含指定的元素。

使用陣列只要需要一個列表，其中元素是以特定的順序排序的。

其他的嘗試

在陣列上嘗試下面這些常見的方法：

each
collect
first 和 last
shuffle

可以參考這個文件了解更多詳細資訊：http://www.ruby-doc.org/core-2.1.2/Array.html

8.雜湊

雜湊是資料的集合，雜湊中的資料的每個元素是按名稱來定址。作為一個比喻，想一下冰箱。如果要跟蹤放在冰箱內的東西，我們並不關心它的放在哪裡 - 順序並不重要。相反只是按名稱去組織這些東西。如名稱「apples」可能具有值3，則名稱「oranges」可能具有值1，並且「carrots」值為12。在本範例中，就可使用雜湊。

鍵/值對

雜湊是無序的集合，其中資料被組織成「鍵/值對」。雜湊的語法更複雜，需要一些習慣：

irb(main):001:0> produce = {"apples" => 3, "oranges" => 1, "carrots" => 12}
=> {"apples"=>3, "oranges"=>1, "carrots"=>12}
<e are #{produce['oranges']} oranges in the fridge."
There are 1 oranges in the fridge.
=> nil
irb(main):003:0>

鍵用作為地址，值是該地址的資料。在produce雜湊中有包括「apples」和「oranges」的鍵，其值分別為12和3。當建立雜湊時，鍵和值使用=>符號連結。所以雜湊從一個大括號{開始，(由一個鍵，一個=>識別符號和一個由逗號分隔的值組成的零個或多個條目，然後以一個關閉的大括號}結束。

再嘗試一些程式碼：

irb(main):006:0> produce["grapes"] = 219
=> 219
irb(main):007:0> produce
=> {"grapes"=>219}
irb(main):008:0> produce["oranges"] = 66
=> 66
irb(main):009:0> produce
=> {"grapes"=>219, "oranges"=>66}
irb(main):010:0> produce.keys
=> ["grapes", "oranges"]
irb(main):011:0> produce.values
=> [219, 66]
irb(main):012:0>

在這些說明的第一行中，向雜湊新增了一個新值。由於「grapes」鍵不在原始雜湊中，所以它的值為221。雜湊中的鍵必須是唯一的，所以當對product [「oranges」]使用相同的語法時，它會看到鍵「oranges」已經在列表中，並且用6替換值。keys 和 values方法會列出所有鍵和值。

簡化雜湊語法

通常會使用符號作為雜湊的鍵。當所有的鍵都是符號時，可以使用一個速記語法：

irb(main):012:0> produce = {apples: 3, oranges: 1, carrots: 12}
=> {:apples=>3, :oranges=>1, :carrots=>12}
irb(main):013:0> puts "There are #{produce[:oranges]} oranges in the fridge."
There are 1 oranges in the fridge.
=> nil
irb(main):014:0>

請注意，鍵以冒號結尾，而不是以冒號開始，即使這些是符號。這個簡化的語法能在Ruby 1.9及更高版本配合使用。要了解正在使用的是哪個版本的Ruby，可在控制台中輸入「ruby -v」。

9. 條件

條件語句評估求值結果為true或false。最常見的條件運算子是==(相等)，>(大於)，>=(大於或等於)，<(小於)和<=(小於或等於)。

一些物件也有返回true或false的方法，因此它們在條件語句中使用。例如，每個物件都有方法.nil？ 只有當物件為nil時才返回：true。陣列有一個名稱為.include的方法如果陣列包含指定的元素，則返回true。 Ruby中的約定方法名稱以？結尾返回true或false。

條件分支/指令

為什麼要有條件語句？最常見的是控制條件指令，特別是：if/elsif/else結構。在IRB中新增一個這樣的方法來寫一個例子：

def water_status(minutes)
  if minutes < 7
    puts "The water is not boiling yet."
  elsif minutes == 7
    puts "It's just barely boiling"
  elsif minutes == 8
    puts "It's boiling!"
  else
    puts "Hot! Hot! Hot!"
  end
end

# run method with difference parameter
water_status(5)
water_status(7)
water_status(8)
water_status(9)

嘗試使用：water_status(5)，water_status(7)，water_status(8)和water_status(9)執行該方法。

理解執行流程

當minutes值為5時，執行結果是什麼？因為minutes = 5小於7，所以列印出來的結果為：「The water is not boiling yet.」

當minutes值為7時，執行結果是什麼？因為minutes值等於7，所以列印出來的結果為：「It's just barely boiling」

當minutes值為8時，執行結果是什麼？因為minutes值等於8，所以列印出來的結果為：「It's boiling!」

當minutes值為9時，執行結果是什麼？因為minutes = 9，它比較了前面的幾個值：5，7，8，但是都沒有匹配項，所以最後執行到else語句塊中，列印出來的結果為：「Hot! Hot! Hot!」

if語句可能的結構

if語句有以下可能的結構：

if語句的指令只有在語句為真時執行。
if語句後面可有零或多個elsif語句，其指令僅在語句為真時執行
if語句後面零或一個else語句，如果沒有一個if或elsif語句為真，則執行else語句中的指令。

if/else if/else結構中只能在一個部分可以執行它的指令。例如，如果if是真的，Ruby將永遠不會執行elseif或else，也就是說永遠只執行其中一塊。

相等與分配值

編寫條件語句時遇到常見錯誤是書寫=和==，以及它們的區別。

=符號表示賦值。表示「拿右邊的東西，把它黏在左邊的任何東西」
==表示為這是一個問題。表示「右邊的東西是等於左邊的東西嗎？」

還可以使用邏輯運算子組合條件語句。最常見的是「邏輯與」和「邏輯或」。在Ruby中，您可以使用這樣的雙符號(&&)來書寫表示一個「邏輯和」。可以用這樣的雙管道(||)書寫表示一個「邏輯或」。

10. Nil和虛無

什麼是虛無？當我們表達一個東西，沒有確定它是什麼東西的暫時可以叫它為：虛無，不是沒有什麼東西嗎？好的，這太多哲學了，這有確實點難解釋了。

nil是Ruby中用於表達「虛無」的方式。

如果有三個雞蛋，您吃三個雞蛋，那麼可能認為現在您「沒有什麼」蛋了，但是在雞蛋方面有「0」個。0是什麼？它是一個數位，它並不是「虛無」。

如果使用一個單詞，如「hello」這樣的字串，那麼刪除「h」，「e」，「l」和「o」，你可能會認為沒有什麼，但是現在真的有「」，它是一個空字串，並不是「虛無」。

nil是Ruby的虛無的想法的表示。當要求不存在的東西時，通常會遇到這種情況。例如，當檢視陣列時，建立了一個包含五個元素的列表，然後要獲取列表中新增第六個元素。但是沒有第六個元素，所以Ruby給了nil。在第六個元素的地方它並不是空白(「」)，也不是數位0，它是空/nil。

編寫Ruby程式碼時遇到的大部分錯誤是涉及nil值的。以為某個位置有資料值，試圖使用使用這個資料值去做一些事情，但沒有這樣的資料值，不能做任何事情，所以Ruby引發了一個錯誤。

11. 物件，屬性和方法

Ruby是物件導向的程式設計語言

Ruby是一種物件導向的程式設計語言，在與VM內部互動的所有東西都是物件。每條資料都是一個物件。物件儲存的資訊稱為屬性，可以執行物件的方法。

作為一個物件的例子，想像你是一個人。你有像高度，重量和眼睛顏色的屬性。你有「走路」，「跑步」，「洗碗」和「白日夢」的方法。不同型別的物件具有不同的屬性和方法。在接下來的章節中，將介紹一些Ruby中常見的特定型別的物件。

類和範例

在物件導向程式設計中，我們定義了類，它們是類別或型別的東西的抽象描述。它定義了該型別的所有物件的屬性和方法。

定義一個類

例如，考慮對一個學校資訊建模。要建立一個名為「Student」的類，表示學生的抽象。 Student類將定義如：first_name，last_name和primary_phone_number的屬性。它可以定義一個用於學生自我介紹的方法：introduction。

嘗試在IRB編寫上面程式碼：

class Student
  attr_accessor :first_name, :last_name, :primary_phone_number

  def introduction
    puts "Hi, I'm #{first_name}!"
  end
end

attr_accessor方法是用於定義類的範例的屬性。

建立類的範例

Student類本身不代表學生，這是學生資訊表示模型。要表示一個實際的學生，需要建立一個Student類的範例。

想像你就是一個學生，不是一個抽象的概念，因為你是一個實際的人。這個實際的人是Student類的一個範例 - 它是一個抽象思想的實現。一個實際的人具有屬性：first_name，last_name 和 primary_phone_number 的實際資料(比如：你的first_name是「愛華」，last_name是「李」等等)。

另一方面，Student類有幾個抽象的屬性： first_name，last_name 和 primary_phone_number，我們不能提前確定它們。

從檔案執行Ruby

一般情況下，很少在IRB中定義類。這是因為IRB只是一個便簽本(不能很好的儲存程式碼)，記得嗎？下面來看看如何從檔案中執行Ruby。

退出IRB對談(輸入：exit或 Ctrl + D)
注意終端當前在哪個檔案夾，進入你的「工作目錄」(本教學中，程式碼都是寫在：F:\worksp\ruby)
使用純文字編輯器建立一個名為student.rb的檔案。
將檔案儲存在student.rb檔案中。
從終端執行檔案：

ruby student.rb

由於這個檔案是空的，所以不應該得到任何輸出。

建立Student類

在文字編輯器中，開始編寫類的結構：

class Student

end

在類的內部，通常使用def關鍵字定義一個或多個方法，如下：

class Student
  def introduction
    puts "Hi, I'm #{first_name}!"
  end
end

請注意，puts行正在計算求值一個名為first_name的方法，該方法返回學生的名字。下面可以進一步新增之前使用的三個屬性：

class Student
  attr_accessor :first_name, :last_name, :primary_phone_number

  def introduction
    puts "Hi, I'm #{first_name}!"
  end
end

執行檔案

回到終端，嘗試用ruby student.rb執行檔案。應該不會看到有結果輸出。

這是為什麼呢？上面步驟中已經定義了一個Student類，並表示一個學生有一個名為introduction的方法以及一些屬性 - 但是實際上並沒有建立Student類的範例或呼叫任何方法。

建立範例

當定義一個類後，還要建立類的一個範例，如下所示：

frank = Student.new

在Student類上呼叫new方法並將其儲存到變數frank中。當有了這個類的範例以後，就可以呼叫範例的方法來設定或獲取其屬性。

使用以下語法呼叫方法：object.method_name。在上面範例中，建立一個範例變數：frank，現在可以通過呼叫 frank.introduction 來獲取學生的介紹資訊了。

在檔案中建立一個範例

在student.rb檔案的底部，在Student類的end關鍵字之後，新增以下內容：

frank = Student.new
frank.first_name = "Frank"
frank.introduction

最終完整的程式碼如下所示 -

class Student
  attr_accessor :first_name, :last_name, :primary_phone_number

  def introduction
    puts "Hi, I'm #{first_name}!"
  end
end

frank = Student.new
frank.first_name = "Max"
frank.introduction

儲存程式碼並返回到終端，再次執行ruby student.rb。現在應該輸出：「Hi, I'm Max!」

方法引數

有時，方法使用一個或多個引數來完成一些事情。例如，可以呼叫 frank.introduction('Minlee')，讓它向Minlee介紹自己。引數可以是數位，字串或任何種類的物件，下面修改introduction方法，以使用一個引數：

class Student
  attr_accessor :first_name, :last_name, :primary_phone_number

  def introduction(target)
    puts "Hi #{target}, I'm #{first_name}!"
  end
end

frank = Student.new
frank.first_name = "Maxsu"
frank.introduction('Minlee')

儲存程式碼並返回到終端，再次執行ruby student.rb。現在應該輸出：「Hi Minlee, I'm Maxsu!」

返回值

在Ruby中，每次呼叫方法時都會得到一個值。預設情況下，Ruby方法返回其評估求值的最後一個表示式的值。

現在向Stuent類中新增一個方法：favorite_number，如下所示 -

class Student
  attr_accessor :first_name, :last_name, :primary_phone_number

  def introduction(target)
    puts "Hi #{target}, I'm #{first_name}!"
  end

  def favorite_number
    7
  end
end

frank = Student.new
frank.first_name = "Maxsu"
puts "Maxsu's favorite number is #{frank.favorite_number}."

開啟終端執行上面程式碼，應該看到：「Maxsu's favorite number is 7」。檔案的最後一行呼叫的是favorite_number方法。該方法的最後一行(只有)行是第7行。這個表示式作為方法的返回值，該值返回給呼叫該方法的任何人。在例子中，這7數位值返回並被插入到字串中。

注意：寫在最後，需要注意的是：這篇教學包教不包會！