# **第 1 章 Ruby 初探**
那么，我们赶快来看一下 Ruby 能做些什么。
本章会介绍以下内容。
-
**使用 Ruby**
了解如何使用 Ruby 编写并执行程序。
-
**使用字符和数值**
了解字符和数值是如何输出、计算以及给变量赋值等内容。
-
**使用条件判断和循环处理**
了解如何通过字符串或数值比较进行条件判断处理，以及如何进行循环处理。
读完本章，大家就能大概掌握用 Ruby 编写程序的方法了。
### **1.1 Ruby 的运行方法**
首先，让我们用 Ruby 编写一个在屏幕上输出字符的小程序。
Ruby 程序有多种执行方法，其中最常见的方法是使用 ruby 命令来执行，其次就是使用 irb 命令，以交互式命令行方式来执行。若只是想执行小程序，使用 irb 命令会相对简单一点。
接下来，我们先介绍 ruby 命令以及 irb 命令的使用方法。
另外，读者如果还没安装 Ruby，请参考附录 A 预先安装好 Ruby 运行环境。
> **注** 本书适用于 Ruby 2.0 或者 Ruby 1.9。由于 Mac OS X 和 Linux 系统默认安装的 Ruby 版本比较旧，因此请读者安装新版本的 Ruby。
### **1.1.1 ruby 命令的执行方法**
首先，让我们看看代码清单 1.1 的程序。
**代码清单 1.1 helloruby.rb**
~~~
print("Hello, Ruby.\n")
~~~
> **注** 日文 Windows 系统中的 \ 会显示为￥。原则上，本书统一书写为 \。
各位是否有些沮丧呢？一般听到“程序”，我们可能会联想到一长串密码似的东西。但这个程序的代码只有一行，总共才 20 来个字符。可这的确是一个真真切切的程序，执行后就可以达到我们预想的目的。
请大家打开编辑器，写入上述程序，将文件名修改为 helloruby.rb，保存文件。.rb 是 Ruby 程序的后缀，表示这个文件内容是 Ruby 程序。
> **备注** 写代码时会用到编辑器或者 IDE，它们的相关内容请参考 A.5 节。
接下来让我们启动控制台，执行程序。
> **备注** 关于控制台的启动方法，请参考附录 A 里各操作系统的说明。
启动控制台后，使用 cd 命令，移动到存放 helloruby.rb 的文件夹中。例如，使用 Windows，文件放在 C 盘的 src 文件夹（`c:\src`），然后执行以下命令，
~~~
> cd c:\src
~~~
接着再执行，
~~~
> ruby helloruby.rb
~~~
执行后，如图 1.1 所示，会显示“`Hello, Ruby.`”。
**图 1.1 执行 Ruby**
> **备注** 如果执行时出错，请参考附录 A 以及 B.5 节的内容。
### **1.1.2 irb 命令的执行方法**
接下来，我们介绍 irb 命令的执行方法。
与 ruby 命令一样，irb 命令在控制台执行，不过不需要指定程序文件。
执行 irb 命令后，就会出现以下这样的命令提示符。1
1使用 Ruby Instarller for Windows 安装包安装的 Ruby，在执行 irb 命令的时候有可能会显示“DL is deprecated, please use Fiddle”这样的警告。这是由于 Ruby Instarller for Windows 安装包附带的 readline 库引用了名为 DL 的旧版本的库，但这个警告不会对使用有任何影响。——译者注
> **执行示例**
~~~
> irb
irb(main):001:0>
~~~
在这里，只需把刚才代码清单 1.1 的代码原封不动地在控制台写一次，然后直接按下回车键，即可执行程序。
> **执行示例**
~~~
irb(main):001:0> print("Hello, Ruby.\n")
Hello, Ruby. ← print 方法输入的结果
=> nil
irb(main):002:0>
~~~
> **备注** 第三行的 `nil` 是 `print` 方法的返回值。关于方法的返回值我们将在 7.3.1 节详细说明。
像这样，在控制台写的程序可以马上在控制台里执行，这对进行简单的小测试非常方便。但是，这个方法并不适合大程序，这时我们应该考虑使用 ruby 命令。
> **注** 在使用 Mac OS X 时，irb 命令会有无法正确输入日语的情况。这时可在 irb 命令后加上 --noreadline 选项，执行 irb --noreadline 命令。这样一来，关闭 readline 功能后，就可以正常输入日语了。但请注意，由于关闭了 readline 功能，在控制台编辑已经输入的字符、查看历史输入记录等功能都将无法使用。
在控制台输入 `exit` 后，按回车键，或者同时按下 Ctrl + d，都可以终止 irb 命令。
### **1.2 程序解说**
接下来，让我们详细解说一下代码清单 1.1 的程序，虽然代码只有孤零零的一行。
### **1.2.1 对象**
首先，请留意 `"Hello, Ruby.\n"` 这部分。
这部分被称为 String 对象或者字符串对象，也可以直接称这部分为字符串。也就是说，这部分是一个代表字符串 Hello, Ruby. 的对象（图 1.2）。
**图 1.2 数据与对象**
字符串、数值、时间等各种数据，在 Ruby 中都是对象。
> **备注** 字符串末尾的 \n 是换行符。
### **1.2.2 方法**
这一次，让我们留意一下 `print` 这部分。
`print` 是一个方法。所谓方法，就是对象的行为。数值的加法或乘法运算、字符串的合并、某时刻一小时后或者一天后的计算等操作，都是通过执行方法来实现。
`print` 方法的作用就是输出 `()` 里的内容。因此，执行 helloruby.rb 后，在控制台显示了字符串对象——`Hello, Ruby.`。
我们把执行方法时必需的条件称为参数。例如，我们在说明 `print` 方法时，会说“`print` 方法会把作为参数传递过来的字符串，输出到控制台中”。
我们更换一下 `print` 方法的参数，试一下把它换成其他字符串。
~~~
print("Hello, RUBY!\n")
~~~
这一次，我们希望输出大写字母的 `Hello, RUBY!`。是不是感觉会更加精神点呢？
### **1.3 字符串**
我们再详细看看有关字符串的内容。
### **1.3.1 换行符与 \**
上文我们提到过字符 `\n` 是换行符。利用换行符，我们可以用普通的字符达到换行的效果，例如，为达到以下效果，
~~~
Hello,
Ruby
!
~~~
程序可以这么写：
原本也可以像下面一样这么写：
~~~
print("Hello,
Ruby
!
")
~~~
输出结果虽然与第一种写法是一样的，但是，这样的写法会降低程序的可读性，因此并不是一个好的写法。既然 Ruby 已经帮我们准备了换行符，我们就直接用第一种方法吧。
除了 `\n` 以外，当我们想在字符串里嵌入特殊符号时，也会用到 \。双引号是表示字符串开始和结束的符号，假设我们希望字符串里包含双引号，程序要写成 `\"`。
~~~
print("Hello, \"Ruby\".\n")
~~~
的输出结果为：
~~~
Hello, "Ruby".
~~~
像这样，程序会对字符串里 \ 后的字符做特殊处理。2 因此，如果字符串里需要包含 \，程序要写成 \\。例如，
2这个过程称为转义，\ 称为转义字符。——译者注
~~~
print("Hello \\ Ruby!")
~~~
的输出结果为：
~~~
Hello \ Ruby!
~~~
请注意，两个 \ 的输出结果是一个 \。
### **1.3.2 ' ' 与 " "**
创建字符串对象除了可以使用`" "`（双引号）外，也可以使用`' '`（单引号）。我们试试把之前程序的双引号换成单引号，看一下有什么样的效果。
~~~
print('Hello, \nRuby\n!\n')
~~~
这次的输出结果为：
~~~
Hello, \nRuby\n!\n
~~~
程序会原封不动地输出单引号里的内容。
也就是说，在单引号里，像 `\n` 这样的特殊字符不经过转义，程序会原封不动地直接输出。但也有例外，例如在字符串里想嵌入 \ 与单引号时，还是需要在之前加上 \。也就是像这样，
~~~
print('Hello, \\ \'Ruby\'.')
~~~
的输出结果为：
~~~
Hello, \ 'Ruby'.
~~~
### **1.4 方法的调用**
关于方法，我们再详细说明一下。 Ruby 在调用方法时可以省略 ()。因此，代码清单 1.1 的 `print` 方法可以这样写：
~~~
print "Hello, Ruby.\n"
~~~
另外，如果想连续输出多个字符串，可以用逗号（`,`）分隔各字符串，程序会按顺序输出字符串。因此，如下写法也是可以的：
~~~
print "Hello, ", "Ruby", ".", "\n"
~~~
虽然这种写法可以方便地输出多个字符串，但是如果遇到比较复杂的参数，使用 `()` 会更加便于理解。因此，建议在习惯 Ruby 的语法之前，不要使用省略 `()` 的写法。在一些较为简单的情况下，本书会使用省略 `()` 的写法。
一般来说，Ruby 是以从上到下的顺序执行方法的。例如，执行下面的程序会得到相同的结果，也就是 `Hello, Ruby.`。
~~~
print "Hello, "
print "Ruby"
print "."
print "\n"
~~~
### **1.5 puts 方法**
`puts` 方法与 `print` 方法稍有区别，`puts` 方法在输出结果的末尾一定会输出换行符。用 `puts` 方法时，代码清单 1.1 的程序可改写为这样：
~~~
puts "Hello, Ruby."
~~~
不过，当参数为两个字符串时，
~~~
puts "Hello, ", "Ruby!"
~~~
各字符串末尾都会加上换行符，因此会输出下面的结果：
~~~
Hello,
Ruby!
~~~
某些情况下，使用 `print` 方法可能会顺手些；而某些情况下，使用 `print` 方法并不方便。请大家按照实际情况选择该使用哪个方法。
### **1.6 p 方法**
接下来，我们再介绍一个与输出有关的方法。Ruby 提供了一个更简单的输出对象内容的方法——`p` 方法。
无论使用 `print` 方法还是 `puts` 方法，输出数值 1 和字符串 `"1"` 时，结果都只是单纯的 1。这样一来，我们就无法判断输出的结果到底是属于哪个对象。这种情况下，`p` 方法可以很好地解决这个问题。使用 `p` 方法时，数值结果和字符串结果会以不同的形式输出。让我们赶快来尝试一下。
~~~
puts "100" #=> 100
puts 100 #=> 100
p "100" #=> "100"
p 100 #=> 100
~~~
> **备注** 本书在表示程序输出内容时，会在方法的旁边添加`#=>` 字符，其右侧即为方法的输出结果。在这个例子里，`puts "100"`、`puts 100`、`p 100` 的输出结果为字符串 `100`，`p "100"` 的输出结果为字符串 `"100"`。
像这样，输出结果为字符串时，输出结果会被双引号括起来，一目了然。另外，使用 `p` 方法时，换行符（`\n`）、制表符（`\t`）等特殊字符不会转义，会像下面那样直接输出（代码清单 1.2）。
**代码清单 1.2 put_and_p.rb**
~~~
puts "Hello, \n\tRuby."
p "Hello, \n\tRuby."
~~~
> **执行示例**
~~~
> ruby puts_and_p.rb
Hello,
Ruby.
"Hello, \n\tRuby."
~~~
如果只是需要输出程序执行的结果、信息等，可以选择 `print` 方法；如果想确认程序的执行情况，则可选择 `p` 方法。原则上，`p` 方法是提供给编程者使用的。
### **1.7 中文的输出**
到目前为止，我们使用的字符串都只包含字母。
接下来，我们看看如何输出中文字符。其实，输出中文字符也不是多难的事，只要把双引号内的字母换成中文字符即可。像下面这样：
**代码清单 1.3 kiritsubo.rb**
~~~
print "话说某个朝代，后宫妃嫔甚多，\n"
print "其中有一宫女，出身并不十分高贵，却蒙圣恩宠爱。\n"
~~~
> **执行示例**
~~~
> ruby kiritsubo.rb
话说某个朝代，后宫妃嫔甚多，
其中有一宫女，出身并不十分高贵，却蒙圣恩宠爱。
~~~
不过，编码设定不当也会导致输出错误、乱码等情况。遇到这样的情况时，请参考专栏“中文使用注意事项”。
> **专栏**
> **中文使用注意事项**
> 在某些 Ruby 运行环境里，执行包含中文的脚本时，有可能出现以下错误。
> > **执行示例**
~~~
> ruby kiritsubo.rb
kiritsubo.rb:1: invalid multibyte char (US-ASCII)
kiritsubo.rb:1: invalid multibyte char (US-ASCII)
~~~
> 这是由于编写程序时没有指定程序的编码方式造成的。Ruby 程序的编码方式，是通过在程序的首行代码添加注释“`# encoding: 编码方式`”来指定的（编码的规则称为 encoding）。我们称这个注释为魔法注释（magic comment）。
> 例如，使用简体中文版 Windows 常用编码 GBK 编写代码时，可像下面这样写魔法注释：
~~~
# encoding: GBK
print "话说某个朝代，后宫妃嫔甚多，\n "
print "其中有一宫女，出身并不十分高贵，却蒙圣恩宠爱。\n "
~~~
> 这样指定程序的编码方式后，Ruby 在执行程序时就可以正确识别程序中的中文。下表是各平台常用的编码方式。平台有多个常用编码方式时，请按照实际情况选择适合的编码方式。
<table border="1" data-line-num="322 323 324 325 326 327" width="90%"><thead><tr><th> <p class="表头单元格">平台</p> </th> <th> <p class="表头单元格">编码方式</p> </th> </tr></thead><tbody><tr><td> <p class="表格单元格">Windows</p> </td> <td> <p class="表格单元格">GBK（或者GB 2312）</p> </td> </tr><tr><td> <p class="表格单元格">Mac OS X</p> </td> <td> <p class="表格单元格">UTF-8</p> </td> </tr><tr><td> <p class="表格单元格">Unix</p> </td> <td> <p class="表格单元格">UTF-8</p> </td> </tr></tbody></table>
> 另外，从 Ruby 2.0 开始，若没指定魔法注释，Ruby 会默认使用 UTF-8 编码方式。因此，在 Ruby 2.0 中如果希望代码采用 UTF-8 的编码方式时，可省略魔法注释 。
> 除此以外，使用上述 p 方法输出中文时，有时也会出现乱码的情况。这时，可使用“`-E 编码方式`”这个选项来指定输出结果的编码方式。例如，希望以 UTF-8 编码方式在控制台输出结果，可像下面这样执行命令：
> > **执行示例**
~~~
> ruby -E UTF-8 脚本文件名 ← 脚本执行
> irb -E UTF-8 ← irb 启动
~~~
### **1.8 数值表示与计算**
讲解了字符串之后，让我们再来看看 Ruby 是怎么处理数值的。在 Ruby 程序里，整数和小数（浮点数）的处理方式都很自然。
### **1.8.1 数值**
首先，让我们先了解一下 Ruby 是如何表示数值的。1.2 节提到，Ruby 中的字符串是以字符串对象的形式存在的。同样地，数值也是以“数值对象”的形式存在的。也就是说，在程序里操作的都是数值对象。
Ruby 的整数的表示方法很简单。直接输入数字就可以了，例如，
~~~
1
~~~
表示 1 的整数（`Fixnum`）对象。同样地，
~~~
100
~~~
表示 100 的整数对象。
再如，
~~~
3.1415
~~~
这表示的是 3.1415 的浮点数（`Float`）对象。
> **备注** `Fixnum` 和 `Float` 是对象所属类（class）的名称。类的详细内容我们将会在第 4 章和第 8 章说明。
数值的输出与字符串输出一样，也是用 `print` 方法和 `puts` 方法。
~~~
puts(10)
~~~
执行以上代码后，
> **执行示例**
~~~
10
~~~
会输出到屏幕中。
### **1.8.2 四则运算**
Ruby 还可以对数值进行运算，并输出其结果。我们来看看 Ruby 是怎么进行四则运算的。首先，我们用一下 irb 命令。
> **执行示例**
~~~
> irb --simple-prompt
>> 1 + 1
=> 2 ← 1 + 1 的执行结果
>> 2 - 3
=> -1 ← 2 - 3 的执行结果
>> 5 * 10
=> 50 ← 5 * 10 的执行结果
>> 100 / 4
=> 25 ← 100 / 4 的执行结果
~~~
> **备注** irb 命令后的选项 --simple-prompt 会简化 irb 的输出结果。
在一般的编程语言里，乘法运算符用 *，除法运算符用 /。Ruby 也延续了这个习惯。
让我们再试一下复杂点的四则运算。四则运算的基本原则是“先乘除后加减”，Ruby 也遵循这个原则。也就是说，
~~~
20 + 8 / 2
~~~
的结果是 24。如果 20 + 8 后再想除 2，可以使用括号，
~~~
(20 + 8) / 2
~~~
这时答案为 14。
### **1.8.3 数学相关的函数**
除四则运算外，Ruby 中还可以使用数学函数，如平方根、sin 和 cos 等三角函数、指数函数等。使用数学函数时，必须在函数前加上 `Math.` 标识。
> **备注** 不想在函数前加 `Math.` 时，则需要 `include Math` 这段代码。关于这些用法，我们会在 8.6.1 节进行说明。
求正弦时使用 `sin` 方法，求平方根时使用 `sqrt` 方法。执行相对应的函数方法，即可得到该函数的计算结果。一般我们称这一过程为“执行方法后得到结果”，所得到的结果则称为返回值。
> **执行示例**
~~~
> irb --simple-prompt
>> Math.sin(3.1415)
=> 9.26535896604902e-05 ← sin 方法的返回值
>> Math.sqrt(10000)
=> 100.0 ← sqrt 方法的返回值
~~~
> **注** 不同的 Ruby 版本，或者在不同平台下执行时，返回值的位数可能会不同。
第一个返回值的结果是 9.26535896604902e-05，这是一种用来表示极大数或极小数的方法。“`（小数）e（整数）`”表示“`（小数） *10 的（整数）次幂`”。这个例子中，其结果值为“9.26535896604902 * 10 的-5 次幂”，也就是 0.0000926535896604902。
### **1.9 变量**
变量是程序里不可缺少的元素之一。可以将其理解为给对象贴上的标签。
我们可以像下面这样给对象贴上标签（图 1.3）：
**变量名 = 对象**
我们称这个过程为“将对象赋值给变量”。
**图 1.3 变量和对象**
~~~
alphabet = "abcdefg"
num = 10
age = 18
name = 'TAKAHASHI'
~~~
为了说明如何使用变量，让我们看看以下这个求长方体表面积和体积的例子（代码清单 1.4）。
**代码清单 1.4 area_volume.rb**
~~~
x = 10
y = 20
z = 30
area = (x*y + y*z + z*x) * 2
volume = x * y * z
print "表面积=", area, "\n"
print "体积=", volume, "\n"
~~~
若不使用变量，则程序会像下面这样：
~~~
print "表面积=", (10*20 + 20*30 + 30*10) * 2, "\n"
print "体积=", 10*20*30, "\n"
~~~
这样一来，一旦要修改一个值，那么好几个地方也必须一起修改。上例只有两行代码，修改起来并不太麻烦，但遇到比较复杂的程序时，修改起来就会非常费劲。
另外，变量还可以清晰地表示某个值所代表的含义。因此，为变量起一个容易理解的名称是非常重要的。例如，
~~~
hoge = (foo*bar + bar*baz + baz*foo) * 2
funi = foo * bar * baz
~~~
像这样的代码，使人完全搞不清楚这个程序的目的。所以，建议大家平时多加注意，最好使用 `area`、`volume` 等意义明确的单词作为变量名。
### **print方法和变量**
让我们再回顾一下print 方法。
~~~
print "表面积 =", area, "\n"
~~~
这个 `print` 方法有三个参数：`"表面积 = "`、`area`、`"\n"`。`print` 方法会按照顺序，输出这三个参数。
`"表面积 ="` 表示值为“`表面积 =`”的字符串，因此 `print` 方法会直接输出。`area` 表示 `area` 这个变量引用的对象，在这个例子里就是 `2200` 这个整数，因此 `print` 方法输出的是该整数值。
最后那个 `"\n"` 是换行符，因此 `print` 方法也会直接输出。
这三个值经过 `print` 方法处理后，会在屏幕输出“`表面积 = 2200`”加换行的结果。
传递给 `print` 方法的字符串参数也可以像下面这样写：
~~~
print "表面积 = #{area}\n"
~~~
`"表面积 = #{area}\n"` 为一个整体的字符串。`#{area}` 这样的写法，表示把 `area` 的值嵌入到字符串中。在字符串里使用 `#{...}` 这样的写法，可以把通过计算后得到的值嵌入到字符串中。输出结果里除了可以嵌入变量名，也可以嵌入 `"表面积 = #{(x*y + y*z + z*x) * 2}\n"` 这样的计算公式，得到的输出结果是一样的。
一般向屏幕输出结果时，我们都希望同时输出换行符，因此使用 `puts` 方法时，连 `\n` 也都不需要了，这样程序会变得更加简洁。
~~~
puts "表面积 = #{area}"
~~~
### **1.10 注释**
我们在程序里可以写注释。注释虽然写在程序里面，但程序并不会执行注释的内容，也就是说，注释的内容对程序的执行结果不会产生任何影响。
大家也许会问：“为什么会在程序里写这种与程序运行无关的东西呢？”的确，对于只执行一次就可以的简单程序，并不需要特别的注释。但是，一般来说，我们都会多次使用写好的程序。那么，若希望记录
-
**程序的名称、作者、发布条件等信息**
-
**程序说明**
等内容时，就需要用到注释。
Ruby 用`#`表示注释的开始 3。某行是以 `#` 开头时，则整行都是注释。某行中间出现`#` 时，则`#`以后部分就都是注释。另外，行的开头用 `=begin` 和 `=end` 括起来的部分也是注释 4。这样的注释方法，在程序开头或结尾写长说明时会经常用到。
3单行注释。——译者注
4多行注释。——译者注
**代码清单 1.5 comment_sample.rb**
~~~
=begin
《Ruby 基础教程（第 4 版）》示例
注释的使用示例
2006/06/16 创建
2006/07/01 追加一部分注释
2013/04/01 第 4 版更新
=end
x = 10 # 宽
y = 20 # 长
z = 30 # 高
# 计算表面积和体积
area = (x*y + y*z + z*x) * 2
volume = x * y * z
# 输出
print "表面积=", area, "\n"
print "体积=", volume, "\n"
~~~
除此以外，注释还有使某行代码“暂时不执行”的作用。
Ruby 没有 C 中使行的某部分成为注释的写法，只要是以`#` 开始的部分，到行末为止一定都是注释。
### **1.11 控制语句**
编程语言中都有控制语句。
控制语句能让程序在某种条件下，改变执行顺序，或者只执行某一部分。
### **控制语句的分类**
控制语句大致可以分成以下几类。
-
**顺序控制**：按照程序的编写顺序，从头到尾执行。
-
**条件控制**：若某条件成立，则执行○○，否则执行 ××。
-
**循环控制**：在某条件成立之前，反复执行○○。
-
**异常控制**：发生某种异常时，执行○○。
顺序控制是程序最常见的处理方式。若不做特殊处理，程序会按照代码的编写顺序执行。
条件控制，是指根据条件执行分支处理。如果没有满足条件，程序会跳过某部分处理，继续执行其他处理。在 Ruby 中，可使用的条件判断语句有 `if`、`unless`、`case` 等。
循环控制，是指根据条件反复执行某个处理。在这种情况下，该处理的执行顺序会与程序编写的顺序不同，执行过一次的程序，会从头再执行一次。
异常控制有点特殊。程序执行时，意料之外的错误发生后，就会跳出正在执行的那部分程序，然后执行其他地方的程序，使程序能继续执行下去。根据实际情况，有时也会让程序马上结束。
接下来，我们进一步介绍条件控制和循环控制。
### **1.12 条件判断：if～then～end**
`if` 语句用于根据条件变化，改变程序的行为。`if` 语句的语法如下所示：
**`if` 条件 `then`
条件成立时执行的处理
`end`**
条件一般是指能返回 `true` 或者 `false` 的表达式。例如比较两个值，相同则返回 `true`，不同则返回 `flase`，这样的表达式可作为条件。
我们在比较数值的大小时，会用到等号、不等号等运算符。在 Ruby 中，`=` 已经被用作赋值运算了，因此判断是否相等的运算符要用两个并列等号`==` 来代替`=`。另外，`≤`和`≥`运算符在 Ruby 中分别用 `<=` 和 `>=` 来替代。
条件表达返回的结果为 `true` 或者 `false`，`true` 表示条件成立，`false` 表示条件不成立。
~~~
p (2 == 2) #=> true
p (1 == 2) #=> false
p (3 > 1) #=> true
p (3 > 3) #=> false
p (3 >= 3) #=> true
p (3 < 1) #=> false
p (3 < 3) #=> false
p (3 <= 3) #=> true
~~~
我们也可以使用`==`运算符比较字符串。字符串内容相同则返回 `true`，内容不同则返回 `false`。
~~~
p ("Ruby" == "Ruby") #=> true
p ("Ruby" == "Rubens") #=> false
~~~
判断值不相等时要使用`!=` 运算符，它与≠意思相同。
~~~
p ("Ruby != "Rubens") #=> true
p (1 != 1) #=> false
~~~
那么，接下来让我们来看一下如何使用这些运算符编写条件语句。代码清单 1.6 是一个简单的程序：变量 a 大于等于 10 时输出 `bigger`，小于 9 时输出 `smaller`。
**代码清单 1.6 bigger_smaller.rb**
~~~
a = 20
if a >= 10 then
print "bigger\n"
end
if a <= 9 then
print "smaller\n"
end
~~~
在这里可以省略 `then` 关键字。
~~~
if a >= 10
print "bigger\n"
end
┊
~~~
如果希望对条件成立和条件不成立时采取不同的处理，我们可以使用 `else` 关键字。
**`if` 条件 `then`
条件成立时执行的处理
`else`
条件不成立时执行的处理
`end`**
使用 `else` 关键字改写刚才的程序后，会变成下面这样，
~~~
if a >= 10
print "bigger\n"
else
print "smaller\n"
end
~~~
### **1.13 循环**
有时，我们会遇到希望多次循环执行同样的处理的情况。下面，我们来介绍两种执行循环处理的方法。
### **1.13.1 while 语句**
`while` 语句是执行循序时用到的一种基本语句。同样地，`do` 关键字可以省略。
**`while` 循环条件 `do`
希望循环的处理
`end`**
-
**例：按顺序输出从 1 到 10 十个数字**
~~~
i = 1
while i <= 10
print i, "\n"
i = i + 1
end
~~~
### **1.13.2 times 方法**
循环处理的循环次数如果已确定，使用 `times` 方法会更加简单。
**循环次数 .`times do`
希望循环的处理
`end`**
-
**输出 100 行“All work and no play makes Jack a dull boy.”**
~~~
100.times do
print "All work and no play makes Jack a dull boy.\n"
end
~~~
`times` 方法被称为迭代器（iterator）。迭代器是 Ruby 的一个特色功能。从迭代器的英语拼写方法我们可以知道，迭代器表示的是循环（iterate）的容器（-or）。类似地，运算符（operator）也就是运算（operate）的容器（-or），等等。总之，迭代器就是指用于执行循环处理的方法。
Ruby 除了 `times` 方法外，还提供了很多迭代器，典型的有 `each` 方法。`each` 方法的相关内容，我们会在第 2 章中与数组、散列一起介绍。
- 推荐序
- 译者序
- 前言
- 本书的读者对象
- 第 1 部分 Ruby 初体验
- 第 1 章 Ruby 初探
- 第 2 章 便利的对象
- 第 3 章 创建命令
- 第 2 部分 Ruby 的基础
- 第 4 章 对象、变量和常量
- 第 5 章 条件判断
- 第 6 章 循环
- 第 7 章 方法
- 第 8 章 类和模块
- 第 9 章 运算符
- 第 10 章 错误处理与异常
- 第 11 章 块
- 第 3 部分 Ruby 的类
- 第 12 章 数值类
- 第 13 章 数组类
- 第 14 章 字符串类
- 第 15 章 散列类
- 第 16 章 正则表达式类
- 第 17 章 IO 类
- 第 18 章 File 类与 Dir 类
- 第 19 章 Encoding 类
- 第 20 章 Time 类与 Date 类
- 第 21 章 Proc 类
- 第 4 部分 动手制作工具
- 第 22 章 文本处理
- 第 23 章 检索邮政编码
- 附录
- 附录 A Ruby 运行环境的构建
- 附录 B Ruby 参考集
- 后记
- 谢辞