## 3.入門
安裝了所需的軟件后,我們就開始吧。
### 3.1。 交互式紅寶石
Ruby 為我們提供了一種與之交互的簡便方法,該功能稱為交互式紅寶石或 irb <sup class="footnote">[ [5](#_footnotedef_5 "View footnote.") ]</sup> 。 使用 irb,你可以在控制臺中鍵入少量的 ruby 代碼,并查看其執行情況。 irb 是檢查 Ruby 小代碼的好工具。 在終端類型`irb`或`irb –-simple-prompt`中,你將得到如下提示
```rb
2.4.0 :001 >
```
如果你輸入`irb`,將會得到上面的提示
```rb
>>
```
如果你鍵入`irb –-simple-prompt`,將會得到上面的提示,從現在開始的示例中,我將使用簡單的提示。 讓我們編寫第一個 hello world 程序,在提示符下鍵入以下內容(不要鍵入`>>`)
```rb
>> puts 'Hello World!'
```
當你按回車鍵時,將得到如下輸出。 在 Ruby 中,puts 用于將某些東西打印到控制臺上。
```rb
Hello World !
=> nil
```
很好,我們在一分鐘內完成了 Hello World 程序。 讓我們檢查一下 56 是 31 的冪
```rb
>> 56**31
=> 1562531701075863192779448904272185314811647640213651456
```
糟糕! 你從來沒有想過會這么多,是嗎? 無論如何,`**`都用于查找升為另一個數字冪的數字。
要退出 irb 并返回到正常的控制臺或終端提示符,請鍵入`quit`或按鍵盤上的`Ctrl+c`。
### 3.2。 做一些數學
計算機是一種可以進行計算或進行一些數學運算的設備。 使用 irb,我們可以進行簡單的數學運算。 如果你不喜歡使用數字,ruby 可以為你完成。 因此,首先讓我們添加以下數字:1、45、67、893、72、56 和-128。 為此,請在你的 irb 提示中輸入這些數字,并用加號“ +”分隔,即可得到結果
```rb
>> 1 + 45 + 67 + 893 + 72 + 56 + -128
=> 1006
```
以下是一些常用的數學運算符,你會發現它們很有用
<colgroup><col style="width: 50%;"> <col style="width: 50%;"></colgroup>
| 操作員 | 他們做什么 |
| + | 加號 |
| -- | 從另一個數字減去一個數字 |
| / | 用一個數字除以另一個數字 |
| * | 兩個數字相乘 |
| ** | 查找一個提升到另一個的冪的數字 |
| % | 找到余數 |
| + = | 向變量添加值并為其賦值 |
| -= | 減去并為變量賦值 |
| * = | 乘法并為變量賦值 |
| / = | 劃分并給變量賦值 |
| %= | 查找余數并將其分配給變量 |
**添加示例:**假設我想將 56 和 72 相加并找到其結果,我可以這樣做,如下所示:
```rb
>> 56+72
=> 128
```
**減法示例:**在此示例中,我從 112 中減去 64
```rb
>> 112-64
=> 48
```
**除法示例:**可以說我想將 117 除以 12 并找到商,我可以像這樣在 Ruby 中進行操作
```rb
>> 117/12
=> 9
```
**Power 示例:**可以說,我想通過求五(把五提高到三的冪)來得到什么,我可以如圖所示在 Ruby 中實現
```rb
>> 5**3
=> 125
```
**模數或余數示例:**我想知道當我們將 21 除以 4 時得到的余數,我可以這樣做
```rb
>> 21%4
=> 1
```
**加賦值示例:**聲明變量 i,將其設置為零,然后將其加 24。 在紅寶石中,你可以如圖所示
```rb
>> i = 0
=> 0
>> i+=24
=> 24
>> i
=> 24
```
最后,當我們鍵入 i 并看到得到 24 時。這意味著我在其中保留了值 24。
**帶賦值的減法示例:**讓我們聲明一個變量 j,為其賦值 50 并從中減去 17
```rb
>> j = 50
=> 50
>> j -= 17
=> 33
>> j
=> 33
```
最后,當我們鍵入 j 時看到 33。這意味著 j 在其中保留值 33。
**帶賦值的乘法示例:**讓我們聲明一個變量 k,將其設置為 3 并乘以 9
```rb
>> k = 3
=> 3
>> k *= 9
=> 27
>> k
=> 27
```
最后,當我們鍵入 k 時,我們得到 27。這意味著 k 在其中保留值 27。
**除法分配示例:**聲明變量 s,將其設置為 25 并除以 5
```rb
>> s = 25
=> 25
>> s /= 5
=> 5
>> s
=> 5
```
最后,當我們鍵入 s 時看到得到 5。這意味著 s 在其中保留值 5。
自己嘗試其他操作員,我已經沒有耐心了。
#### 3.2.1。 空間無關緊要
可以說我要在 62 上加上 54,如何命令 irb 來做到這一點。 應該是 54 + 62 還是我可以留空格,以便代碼可以像 54 + 62 那樣整齊地編寫。 好吧,幸運的是,在 Ruby 中留出空格并不重要,你可以按照以下所示的多種方式為其提供空間,并且仍然獲得相同的結果。
```rb
>> 54+62
=> 116
>> 54 +62
=> 116
>> 54+ 62
=> 116
>> 54 + 62
=> 116
>> 54 + 62
=> 116
```
請注意,加上天氣時它保持 54 或 62 或之間有空格,無論空格有多長,它都會打印出正確的結果。
#### 3.2.2。 小數點
將紅寶石 5 除以 3 時,結果如下
```rb
>> 5/3
=> 1
```
換句話說,它給出商。 實際上 5 除以 3 幾乎是 1.666666666666666667,那么如何獲得此答案? 事實是 5 和 3 是整數,或者沒有小數部分的數字。 如果你想要一個相當準確的答案,可以將你的命令改寫為 Ruby,如下所示
```rb
>> 5.0/3
=> 1.66666666666667
```
以上述方式,我們指定 5.0 而不是 5,換句話說,我們強迫 Ruby 進行浮點數或小數計算,而不是整數計算。 這使 Ruby 給出了一個相當準確的答案。
### 3.3。 變數
變量是在其中存儲價值的東西。 你可以將它們想象成一個可以容納鵝卵石的盒子。 如果一個名為`a`的盒子包含五個小卵石,則其值為 5,如果另一個盒子`b`包含三個卵石,則其值為 3。假設你有一個新盒子`c`,并且希望其值為 框`a`和框`b`的總和,然后你只需在`a`和`b`中加上小卵石的數量,總計 8,在`c`中放入 8 個小卵石即可制成`c = a + b`。 希望你能暗示什么是變量。 讓我們用 Ruby 編程
```rb
>> a = 5
=> 5
>> b = 3
=> 3
>> c = a + b
=> 8
```
讓我們嘗試另一個問題,我以 10 盧比/-的價格從一個農民手中購買了 50 株芒果,將其推向市場,以每蒲式耳 15 盧比的價格出售,我的利潤是多少?
**答案:**
好吧,首先我有 50 個芒果,所以在 irb 中輸入如下所示:
```rb
>> mangoes = 50
=> 50
```
因此,我已將值 50 分配給名為`mangoes`的變量。 接下來,我聲明并為變量`buy_price`賦值為 10,如下所示:
```rb
>> buy_price = 10
=> 10
```
我以類似的方式將 15 分配給名為`sell_price`的變量
```rb
>> sell_price = 15
=> 15
```
現在,每個芒果的利潤是買賣價格之間的差,因此我可以如下所示進行計算
```rb
>> profit = sell_price - buy_price
=> 5
```
賣芒果可獲 5 盧比的利潤,而賣 50 粒芒果會得到什么呢? 它是`profit`與`mangoes`的倍數,如圖所示
```rb
>> total_profit = profit * mangoes
=> 250
```
因此,通過出售 50 個芒果,我們可以賺取?250 /-的利潤。 假設我們已經購買了 72 種芒果,現在我們想知道會有什么利潤,可以通過將`mangoes`的值從 50 更改或更改為 72 并重新計算`total_profit`來輕松實現
```rb
>> mangoes = 72
>> total_profit = profit * mangoes
=> 360
```
現在你可能知道為什么我們稱這些為變量,變量是一個可以包含任何所需值的框。 就像可以從框中添加或刪除小卵石一樣,你可以對變量進行數學運算。
#### 3.3.1。 命名約定
在芒果示例中,你會注意到我給變量的名稱為`buy_price`,`sell_price`,`total_profit`而不是購買`price`,`sell price`,`total profit`,為什么呢? 事實證明,命名變量時必須遵循某種命名約定或規則。 命名變量的規則如下:
* 變量名之間不能有空格
* 變量名稱中除了下劃線 _ 之外,不得有任何特殊字符
* 變量名可以有數字
* 變量名不能以數字開頭
* 變量必須以字符或下劃線開頭
* 大寫字符不應出現在變量的開頭
下面給出的是有效變量名的示例
```rb
mango
total_price
mango_
_mango
buyPrice
boeing747
boeing_747
iam23yrsold
```
以下是無效變量名稱的示例
```rb
34signals
Mango
total cost
```
#### 3.3.2。 下劃線–一個特殊變量
假設我們想找到乘冪為 87 的東西 87,我們可以這樣做
```rb
>> 87 ** 12
=> 188031682201497672618081
```
現在我們想將結果乘以 5 并看到答案,現在上面的結果是一個非常大的 24 <sup class="footnote">[ [6](#_footnotedef_6 "View footnote.") ]</sup> 數字位數,我們必須全部輸入并加一個星號 五得到答案,多數民眾贊成在很多工作! 如果你是一名程序員,那么懶惰就會滲入你的血管,否則你將另謀高就。 一種方法是將該值分配給變量,然后將其乘以 5,如下所示
```rb
>> a = 87 ** 12
=> 188031682201497672618081
>> a*5
=> 940158411007488363090405
```
但是還有另一種簡單的方法,如下所示
```rb
>> 87 ** 12
=> 188031682201497672618081
>> _ * 5
=> 940158411007488363090405
```
我確實發現將 87 提升為 12 的冪,然后我將下劃線 _ 乘以 5! 但是怎么會呢? 下劃線是一種特殊的變量,其中上一次執行的結果會自動存儲。 如果要使用最后獲得的輸出,可以通過使用下劃線 _ 作為變量 <sup class="footnote">[ [7](#_footnotedef_7 "View footnote.") ]</sup> 來執行。
### 3.4。 常數
與變量不同,某些值必須恒定,例如地球半徑恒定,光速恒定。 在處理此類問題的問題中,或者在你完全確定某些值不會改變的情況下,可以使用常量。
常數可以被認為是價值不變的變量。 Ruby 中的常量以大寫字母開頭,然后可以跟字母,數字或下劃線。 現在讓我們有一個名為`Pi`的常數,該常數將等于數學上的 <mstyle displaystyle=""true""><mi>&#x3C0;</mi></mstyle> “ role =” presentation“ style =” position:relative;“ > <nobr aria-hidden="true">π</nobr> <math xmlns="http://www.w3.org/1998/Math/MathML"><mstyle displaystyle="true"><mi>π</mi></mstyle></math> ,只需在 irb 提示符下鍵入以下內容
```rb
>> Pi = 3.1428
=> 3.1428
```
分配了 <mstyle displaystyle=""true""><mi>&#x3C0 的值;</mi></mstyle> “ role =” presentation“ style =” position:relative;“ > <nobr aria-hidden="true">π</nobr> <math xmlns="http://www.w3.org/1998/Math/MathML"><mstyle displaystyle="true"><mi>π</mi></mstyle></math> 改成名為`Pi`的常量,我們現在嘗試查找半徑為 7 個單位的圓的面積,因此請使用忠實的計算器 irb。我們知道圓的面積為 <mstyle displaystyle=""true""><mi>&#x3C0;</mi> <msup><mi>r</mi> <mn>2</mn></msup></mstyle> “ role =” presentation“ style =” position:relative;“; > <nobr aria-hidden="true">πr2</nobr> <math xmlns="http://www.w3.org/1998/Math/MathML"><mstyle displaystyle="true"><mi>π</mi> <msup><mi>r</mi> <mn>2</mn></msup></mstyle></math> ,其中 <mstyle displaystyle=""true""><mi>r</mi></mstyle> “ role =” presentation“ style =” position:relative;“ > <nobr aria-hidden="true">r</nobr> <math xmlns="http://www.w3.org/1998/Math/MathML"><mstyle displaystyle="true"><mi>r</mi></mstyle></math> 是圓半徑,在你的 irb 提示中,我們可以進行如下計算
```rb
>> r = 7
=> 7
>> Pi * r ** 2
=> 153.9972
```
因此,我們發現圓的面積大約為 153.9972 平方單位,非常接近 154 平方單位的精確值。
可以問天氣我們可以改變常數的值嗎? 我并不是說這是不可能的,但是如果我們更改紅寶石,則會警告我們正在更改常量的值,但是在警告之后常量還是會更改。
```rb
>> Pi=5
(irb):35: warning: already initialized constant Pi
=> 5
```
在上面的示例中,我將`Pi`的值重新分配為 5,如第二行所示,Ruby 解釋器的確發出了警告:Pi 已被初始化為常量,但是無論如何 Pi 的值都會更改為 5.強烈建議不要在專業編程中更改常數值。
### 3.5。 弦樂
到目前為止,我們已經了解了數字,現在讓我們來看看文本。 在計算機中,文本稱為字符串 <sup class="footnote">[ [8](#_footnotedef_8 "View footnote.") ]</sup> 。 OK,讓我們看看 Ruby 中的字符串。 讓我們從一個問候世界開始。 在你的 irb 中輸入 hello world,如下所示
```rb
>> "hello world"
=> "hello world"
```
作為響應,你會收到`“hello world”`。 簡而言之,字符串是`“`或`'`包圍的任何東西
現在,通過用單引號包圍上面的問候世界,嘗試上面的示例
```rb
>> 'hello world'
=> "hello world"
```
好吧,你確實得到了同樣的答復。 那么單引號和雙引號有什么區別? 看下面的例子
```rb
>> time_now = Time.new # Get the current time into a variable
=> Fri Jan 15 16:43:31 +0530 2010
>> "Hello world, the time is now #{time_now}"
=> "Hello world, the time is now Fri Jan 15 16:43:31 +0530 2010"
>> 'Hello world, the time is now #{time_now}'
=> "Hello world, the time is now \#{time_now}"
```
首先,我們聲明一個名為`time_now`的變量并將當前時間存儲到其中。 Ruby 中的當前時間是通過`Time.new`命令獲得的。 現在我們有了一個變量,可以將其像`#{put_your_variable_here}`一樣嵌入到字符串中。 因此,我們想告訴世界現在是某個時間,所以我們給出如下所示的命令
```rb
>> "Hello world, the time is now #{time_now}"
=> "Hello world, the time is now Fri Jan 15 16:43:31 +0530 2010"
```
我們得到了適當的結果。 請注意,你已經用雙引號將字符串引起來。 現在讓我們用單引號嘗試相同的操作
```rb
>> 'Hello world, the time is now #{time_now}'
=> "Hello world, the time is now \#{time_now}"
```
我們看到,在這種情況下,世界無法看到現在的時間,而是能夠看到如圖所示的丑陋字符串。
```rb
"Hello world, the time is now \#{time_now}"
```
單引號之間的內容將按原樣打印。 你可能會問為什么#被打印為`\#`,我們很快就會在轉義序列中看到它。
#### 3.5.1。 字符串函數
使用內置于 Ruby 中的內置函數和例程,可以對字符串執行某些很酷的操作。 例如,如果要查找字符串的長度,可以使用`length`函數,如下所示
```rb
>> "my name is billa".length
=> 16
```
有很多功能,其中一些功能在下表中給出。 我必須警告你該表不完整,你必須查看 Ruby 文檔 <sup class="footnote">[ [9](#_footnotedef_9 "View footnote.") ]</sup> 以獲得全面的介紹。
<colgroup><col style="width: 33.3333%;"> <col style="width: 33.3333%;"> <col style="width: 33.3334%;"></colgroup>
| 輸入值 | 輸出量 | 筆記 |
| `"my name is billa".length` | 16 | 長度函數查找字符串的長度 |
| `"my name is billa".reverse` | 阿里布西曼公司 | 反向功能反轉字符串 |
| `"my name is billa".capitalize` | 我叫比拉 | 大寫給定的字符串 |
| `"my name is billa".upcase` | 我的名字叫比拉 | 將小寫字符轉換為大寫 |
| `"MY NAME IS BILLA".downcase` | 我的名字叫比拉 | 將大寫字符轉換為小寫 |
| `"my name is billa".next` | 我的名字叫比爾 | 這是安靜的不合邏輯的功能,可打印下一個邏輯字符串 |
| `"my name is billa".empty?` | 假 | 如果字符串為空,則返回 true,否則返回 false |
| `"".empty?` | 真正 | Returns true if string is empty, else returns false |
好的,我們已經看了一些功能,現在讓我們看看可以對字符串執行哪些操作。 第一個是串聯,其中兩個或多個字符串可以連接在一起,請看下面的示例
```rb
>> "Hello" + " " + "World!"
=> "Hello World!"
```
在上面的代碼中,我加入了三個字符串“ Hello” a(空格)“”和“ World!”。 使用加號,也可以對字符串變量執行相同的操作,如下所示
```rb
>> string_1 = "Hello"
=> "Hello"
>> string_2 = "World!"
=> "World!"
>> string_1 + " " + string_2
=> "Hello World!"
```
好了,我們已經研究了很多,冥想會有所幫助,讓 lets 吟 OM <sup class="footnote">[ [10](#_footnotedef_10 "View footnote.") ]</sup> 凈化并重置我們的思想。 你知道,Ruby 可以為你冥想! 在你的 irb 中輸入以下內容
```rb
>> "OM " * 10
```
為了天堂,不要輸入`>>`! 這是你的結果
```rb
=> "OM OM OM OM OM OM OM OM OM OM "
```
帶數字的乘法運算符打印一個字符串 N 次,其中 N 是在`*`之后給出的數字。
#### 3.5.2。 轉義序列
每當你鍵入類似`puts “Hello World!”`的語句時,Ruby 解釋器都會顯示`Hello World!`。 那就是`“`和`“`之間的所有東西都被打印出來了。 并非總是如此。 你可以在`“`和`“`之間放置一些可以避開正常打印順序的東西。 啟動你的 irb 并輸入以下示例:
```rb
>> puts "Hello \r World!"
World!
=> nil
```
令人驚訝的是,你僅看到`World!`被打印。 你好怎么了? 那么`\r`字符代表回車,這意味著 Hello 會被打印出來。 然后,回車/光標返回到行的開頭,`World!`被覆蓋。 就像`\r`代表回車一樣,`\n`代表換行。 在 irb 中輸入以下示例
```rb
>> puts "Hello \n World!"
Hello
World!
=> nil
```
如你所見,`Hello`在第一行打印,`World!`在下一行打印。 這是因為我們在它們之間放置了換行符`\n`。
好了,現在來看一個場景,我們現在知道`\r`,`\n`以及其他可能不是打印字符。 現在如何在輸出中打印`\n`或`\r`。 事實證明,如下面的示例所示,放置雙反斜杠將在輸出中打印反斜杠。
```rb
>> puts "Hello \\n World! => Hello \n World!"
Hello \n World! => Hello
World!
=> nil
```
`\t`以類似的方式將制表符空格放置在任何位置。 試試下面的例子
```rb
>> puts "Tabs \t leave\tlong spaces"
Tabs leave long spaces
=> nil
```
希望你對字符串有所了解,讓我們繼續...
### 3.6。 使用文字編輯器
到現在為止,你已經將小程序鍵入到你的 irb 中,當你開發大型軟件時,你不能指望最終用戶或客戶繼續將你為他/她開發的語句鍵入控制臺。 交出一個有類型的 Ruby 程序,他們可以運行它來完成某些任務。 讓我們看看如何使用文本編輯器編寫程序。 在“安裝 IDE”部分的前面,我已經鍵入了有關如何安裝名為 Geany 的簡單集成開發環境(IDE)的信息。 如果你使用的是 Ubuntu,請按超級鍵,輸入 Geany,單擊 Geany 圖標,你將獲得它。

你也可以使用其他 IDE,如果需要其他 IDE,請參閱其文檔以獲取安裝說明。 在 IDE 中,鍵入以下程序
```rb
puts "Hello World!"
puts "This time I used text editor"
```
現在,將文件另存為 hello_world.rb 在目錄中,請注意,Ruby 文件以.rb(點 rb)擴展名結尾。 啟動你的終端/控制臺,遷移到存儲程序的目錄,然后在其中鍵入以下內容
```rb
$ ruby hello_world.rb
```
這就是你將如何獲得輸出的方法。
```rb
Hello World!
This time I used text editor
```
精彩! 你已經學會了使用文本編輯器進行編程的方法,你正在變得專業!
### 3.7。 打印東西
研究代碼 hello_world.rb,我們使用了一個名為`puts`的 Ruby 命令,該命令將某些內容輸入輸出,在本例中為你的終端窗口。
```rb
puts "Hello World!"
puts "This time I used text editor"
```
第一行打印 Hello World! 第二張打印`This time I used a text editor`。 如果要在同一行中打印兩件事怎么辦? 為此,請使用`print`命令,為其鍵入一個新程序`hello_world_1.rb`,在文本編輯器中,鍵入以下代碼
```rb
print "Hello World! "
print "Once again I used a text editor"
```
這給出了輸出:
```rb
Hello World! Once again I used a text editor
So you have learned to print something!
```
### 3.8。 獲取輸入
當程序與用戶互動時,它會更有用,讓我們編寫一個程序來詢問我們的名字并向我們問好。 輸入以下代碼(我將其保存為 say_hello.rb)
```rb
puts "Hello I am Zigor, a automated Robot that says Hello"
print "Please enter your name:"
name = gets()
puts "Hello #{name}"
```
現在運行它,這就是輸出的樣子
```rb
Hello I am Zigor, a automated Robot that says Hello
Please enter your name:Karthik
Hello Karthik
```
讓我們通過程序
第一行
```rb
puts "Hello I am Zigor, a automated Robot that says Hello"
```
打印程序名稱為 Zigor 及其自動機器人,祝你好。 然后它打印一個換行符,因此隨后打印的內容轉到下一行
第二行
```rb
print "Please enter your name:"
```
打印出`“Please enter your name:”`,請注意,我們在這里使用了`print`,而不是`puts`,因為我們想在`name:`之后獲得用戶名,如果讓他們在下一行鍵入 name,我會覺得很尷尬 ,為避免換行,我使用`print`而不是`puts`。
當用戶輸入名稱并按 Enter 時,它會被`gets()`函數捕獲,并且由于這段代碼,你鍵入的內容存儲在名為 name 的變量中
```rb
name = gets()
```
現在,我們的 Zigor 需要做的就是打個招呼,為此我們使用了這段代碼
```rb
puts "Hello #{name}"
```
注意我們如何通過將變量名放在`#{`和`}`之間來將變量名嵌入到字符串中。 通過使用這樣的代碼可以達到相同的效果
```rb
puts "Hello "+name
```
但是前一段代碼看起來更好嗎? 這都是你的選擇。 Ruby 使你可以通過多種方式執行相同的操作。 你可以選擇任何自己喜歡的東西。
在本主題中,你必須要查看的任何行都是具有`gets()`方法或功能的行,它等待鍵盤輸入,當你輸入內容并按 Enter 鍵時,它將獲取你的輸入并將值分配給變量 ,在這種情況下,變量為 name。
### 3.9。 注釋
注釋是你可以放入一個程序中的小筆記,以便你或其他人在進入該程序 7,658 年后會記得或知道它在做什么。 你今天可能很聰明,但是明天你可能不像現在這樣聰明,付錢給你的老板或客戶當時會大喊大叫,以修復優先級錯誤或更新軟件。 打開文本編輯器,然后輸入以下代碼:
```rb
puts "Hello I am Zigor, a automated Robot that says Hello"
print "Please enter your name:"
name = gets()
puts "Hello #{name}"
```
你現在也許可以理解,但是在 7,658 年之后 <sup class="footnote">[ [11](#_footnotedef_11 "View footnote.") ]</sup> ? 到那時,你可能已經完全忘記了 Ruby! 因此,開始評論。 請參見下面的同一程序`comment.rb`,它的外觀如何?
```rb
# The client is an idiot
# he wants me to update a software after 7,658 years.
# The hell with him
puts "Hello I am Zigor, a automated Robot that says Hello" # zigor is some stupid robot
print "Please enter your name:" # Tells the user to enter his name
name = gets() # gets the user name and assigns it to a variable named name
puts "Hello #{name}" # Embeds name into the string that gets printed
```
查看上面的代碼,你已經在前三行中介紹了有關 client 的一些信息。 這些行以#開頭(哈希或校驗符號)。 復選標記后的內容是注釋,注釋不會干擾程序的執行,但可以用來向人們提供程序中正在發生的事情的視覺提示。
現在讓我們看看這條線
```rb
puts "Hello #{name}" # Embeds name into the string that gets printed
```
在這里,你將`#{name}`括在雙引號中,因此將其視為字符串中的嵌入式 ruby 代碼,而不是注釋,而#將名稱嵌入到要打印的字符串中被視為注釋。
因此,我希望你理解該評論有一天能有所幫助。 專業人士在編寫代碼時總是會發表評論。 他們會很努力,以便幾乎所有閱讀其程序的 Ruby 編碼器都能夠理解它的運行方式。
#### 3.9.1。 多行注釋
如果你想對段落大小發表很多評論,則可以將該文本放在`=begin`和`=end`之間,如下面的程序`comments_multiline.rb`中所示
```rb
=begin
The client is an idiot
he wants me to update a software after 7,658 years.
The hell with him
=end
puts "Hello I am Zigor, a automated Robot that says Hello" # zigor is some stupid robot
print "Please enter your name:" # Tells the user to enter his name
name = gets() # gets the user name and assigns it to a variable named name
puts "Hello #{name}" # Embeds name into the string that gets printed
```
在上面的代碼中,請注意我們如何放置這些文本:
```rb
The client is an idiot
he wants me to update a software after 7,658 years.
The hell with him
```
在`=begin`和`=end`之間,當你執行程序時,在`=begin`和`=end`之間的將被忽略。 因此,不要猶豫,寫很多評論,因為現在你知道有一種方法可以這樣做,它將極大地有益于你和你的其他程序員。
關于`=begin`和`=end`,你必須了解一小件事,那就是它們必須從第一列開始,`=`符號前不應有空格,如果有的話,ruby 會認為其中有一個 編程錯誤,將發出錯誤信號。
- 前言
- 紅寶石
- 先決條件
- 1.安裝 Ruby
- 2.在線資源
- 3.入門
- 4.比較與邏輯
- 5.循環
- 6.數組
- 7.哈希和符號
- 8.范圍
- 9.功能
- 10.可變范圍
- 11.類&對象
- 12.安全導航
- 13.打破大型程序
- 14.結構和 OpenStruct
- 15. Rdoc
- 16. Ruby 樣式指南
- 17.模塊和混入
- 18.日期和時間
- 19.文件
- 20. Proc,Lambda 和塊
- 21.多線程
- 22.異常處理
- 23.正則表達式
- 24.寶石
- 25.元編程
- 26.基準
- 27.測試驅動開發
- 28.觀察者模式
- 29.模板模式
- 30.工廠模式
- 31.裝飾圖案
- 32.適配器模式
- 33.單例模式
- 34.復合模式
- 35.建造者模式
- 36.策略模式
- 贊助商
- 捐
- 人們怎么說
- 版權
- 取得這本書