## 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.策略模式
- 赞助商
- 捐
- 人们怎么说
- 版权
- 取得这本书