入门1

初探

https://www.kancloud.cn/imxieke/ruby-base/107287

Ruby 的运行方法

Ruby 程序有多种执行方法，其中最常见的方法是使用 ruby 命令来执行，其次就是使用 irb 命令，以交互式命令行方式来执行。若只是想执行小程序，使用 irb 命令会相对简单一点。

echo "print(\"Hello World\")" > hello.rb

ruby hello.rb

irb
print("Hello World")

程序解说

对象

print("Hello Ruby")
      ------------
            |__字符串对象

这部分被称为 String 对象或者字符串对象，也可以直接称这部分为字符串。也就是说，这部分是一个代表字符串 Hello, Ruby. 的对象

字符串、数值、时间等各种数据，在 Ruby 中都是对象。

方法

print("Hello Ruby")
----
  |__方法

print 是一个方法。所谓方法，就是对象的行为。数值的加法或乘法运算、字符串的合并、某时刻一小时后或者一天后的计算等操作，都是通过执行方法来实现。

print 方法的作用就是输出 () 里的内容。因此，执行 helloruby.rb 后，在控制台显示了字符串对象——Hello, Ruby.。

我们把执行方法时必需的条件称为参数。例如，我们在说明 print 方法时，会说“print 方法会把作为参数传递过来的字符串，输出到控制台中”。

字符串

换行符与 *
字符是换行符。利用换行符，我们可以用普通的字符达到换行的效果，例如，为达到以下效果
```
Hello,
Ruby
!
```
程序可以这么写：
```
print("Hello,\nRuby\n!\n")
             ---   --  --
              |_____|___|___换行符
```
原本也可以像下面一样这么写：
```
print("Hello,
Ruby
!
")
```
输出结果虽然与第一种写法是一样的，但是，这样的写法会降低程序的可读性，因此并不是一个好的写法。既然 Ruby 已经帮我们准备了换行符，我们就直接用第一种方法吧。
以外，当我们想在字符串里嵌入特殊符号时，也会用到 \ 。双引号是表示字符串开始和结束的符号，假设我们希望字符串里包含双引号，程序要写成 \" 。
```
print("Hello, \"Ruby\".\n")
```
输出结果为：
```
Hello, "Ruby".
```
像这样，程序会对字符串里 \ 后的字符做特殊处理。因此，如果字符串里需要包含 \ ，程序要写成 \\
这个过程称为转义，\ 称为转义字符。
```
print("Hello \\ Ruby!")
```
输出结果为:
```
Hello \ Ruby!
```
请注意，两个 \ 的输出结果是一个 \ 。
' ' 与 " "
创建字符串对象除了可以使用 " "（双引号）外，也可以使用 ' '（单引号）。我们试试把之前程序的双引号换成单引号，看一下有什么样的效果。
```
print('Hello, \nRuby\n!\n')
```
这次的输出结果为：
```
Hello, \nRuby\n!\n
```
程序会原封不动地输出单引号里的内容。
也就是说，在单引号里，像这样的特殊字符不经过转义，程序会原封不动地直接输出。但也有例外，例如在字符串里想嵌入 \ 与单引号时，还是需要在之前加上 \ 。也就是像这样，
```
print('Hello, \\ \'Ruby\'.')
```
输出结果为：
```
Hello, \ 'Ruby'.
```

方法的调用

关于方法，我们再详细说明一下。 Ruby 在调用方法时可以省略 ()。因此, print 方法可以这样写：

print "Hello, Ruby.\n"

另外，如果想连续输出多个字符串，可以用逗号 , 分隔各字符串，程序会按顺序输出字符串。因此，如下写法也是可以的：

print "Hello, ", "Ruby", ".", "\n"

虽然这种写法可以方便地输出多个字符串，但是如果遇到比较复杂的参数，使用 () 会更加便于理解。因此，建议在习惯 Ruby 的语法之前，不要使用省略 () 的写法。在一些较为简单的情况下，本书会使用省略 () 的写法。

一般来说，Ruby 是以从上到下的顺序执行方法的。例如，执行下面的程序会得到相同的结果，也就是 Hello, Ruby.。

print "Hello, "
print "Ruby"
print "."
print "\n"

puts 方法

puts 方法与 print 方法稍有区别，puts 方法在输出结果的末尾一定会输出换行符。用 puts 方法时，print 程序可改写为这样：

puts "Hello, Ruby."

不过，当参数为两个字符串时，

puts "Hello, ", "Ruby!"

各字符串末尾都会加上换行符，因此会输出下面的结果：

Hello,
Ruby!

某些情况下，使用 print 方法可能会顺手些；而某些情况下，使用 print 方法并不方便。请大家按照实际情况选择该使用哪个方法。

p 方法

接下来，我们再介绍一个与输出有关的方法。Ruby 提供了一个更简单的输出对象内容的方法——p 方法。

无论使用 print 方法还是 puts 方法，输出数值 1 和字符串 "1" 时，结果都只是单纯的 1。这样一来，我们就无法判断输出的结果到底是属于哪个对象。这种情况下，p 方法可以很好地解决这个问题。使用 p 方法时，数值结果和字符串结果会以不同的形式输出。让我们赶快来尝试一下。

puts "100"  #=> 100
puts 100    #=> 100
p "100"     #=> "100"
p 100       #=> 100

像这样，输出结果为字符串时，输出结果会被双引号括起来，一目了然。另外，使用 p 方法时，换行符（\n）、制表符（\t）等特殊字符不会转义，会像下面那样直接输出

puts "Hello, \n\tRuby."
p "Hello, \n\tRuby."

输出如下

Hello,
          Ruby.
"Hello, \n\tRuby."

如果只是需要输出程序执行的结果、信息等，可以选择 print 方法；如果想确认程序的执行情况，则可选择 p 方法。原则上，p 方法是提供给编程者使用的。

中文的输出

到目前为止，我们使用的字符串都只包含字母。

接下来，我们看看如何输出中文字符。其实，输出中文字符也不是多难的事，只要把双引号内的字母换成中文字符即可。像下面这样：

print "话说某个朝代，后宫妃嫔甚多，\n"
print "其中有一宫女，出身并不十分高贵，却蒙圣恩宠爱。\n"

不过，编码设定不当也会导致输出错误、乱码等情况。

中文使用注意事项

在某些 Ruby 运行环境里，执行包含中文的脚本时，有可能出现以下错误。

kiritsubo.rb:1: invalid multibyte char (US-ASCII)

这是由于编写程序时没有指定程序的编码方式造成的。Ruby 程序的编码方式，是通过在程序的首行代码添加注释“# encoding: 编码方式”来指定的（编码的规则称为 encoding）。我们称这个注释为魔法注释（magic comment）。

例如，使用简体中文版 Windows 常用编码 GBK 编写代码时，可像下面这样写魔法注释：

# encoding: GBK
print "话说某个朝代，后宫妃嫔甚多，\n "
print "其中有一宫女，出身并不十分高贵，却蒙圣恩宠爱。\n "

这样指定程序的编码方式后，Ruby 在执行程序时就可以正确识别程序中的中文。下表是各平台常用的编码方式。平台有多个常用编码方式时，请按照实际情况选择适合的编码方式。

平台 | 编码方式

```
      |   -
```

Windows | GBK（或者GB 2312） Mac OS X | UTF-8 Unix | UTF-8

另外，从 Ruby 2.0 开始，若没指定魔法注释，Ruby 会默认使用 UTF-8 编码方式。因此，在 Ruby 2.0 中如果希望代码采用 UTF-8 的编码方式时，可省略魔法注释。

除此以外，使用上述 p 方法输出中文时，有时也会出现乱码的情况。这时，可使用“-E 编码方式”这个选项来指定输出结果的编码方式。例如，希望以 UTF-8 编码方式在控制台输出结果，可像下面这样执行命令：

ruby -E UTF-8 脚本文件名
irb -E UTF-8

数值表示与计算

讲解了字符串之后，让我们再来看看 Ruby 是怎么处理数值的。在 Ruby 程序里，整数和小数（浮点数）的处理方式都很自然。

数值

首先，让我们先了解一下 Ruby 是如何表示数值的。Ruby 中的字符串是以字符串对象的形式存在的。同样地，数值也是以“数值对象”的形式存在的。也就是说，在程序里操作的都是数值对象。

Ruby 的整数的表示方法很简单。直接输入数字就可以了，例如，

表示 1 的整数（Fixnum）对象。同样地，

表示 100 的整数对象。

再如，

3.1415

这表示的是 3.1415 的浮点数（Float）对象。

备注 Fixnum 和 Float 是对象所属类（class）的名称。

数值的输出与字符串输出一样，也是用 print 方法和 puts 方法。

puts(10)

执行以上代码后，

会输出到屏幕中。

四则运算

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 的执行结果

在一般的编程语言里，乘法运算符用 *，除法运算符用 /。Ruby 也延续了这个习惯。

让我们再试一下复杂点的四则运算。四则运算的基本原则是“先乘除后加减”，Ruby 也遵循这个原则。也就是说，

20 + 8 / 2

的结果是 24。如果 20 + 8 后再想除 2，可以使用括号，

(20 + 8) / 2

这时答案为 14。

数学相关的函数

除四则运算外，Ruby 中还可以使用数学函数，如平方根、sin 和 cos 等三角函数、指数函数等。使用数学函数时，必须在函数前加上 Math. 标识。

不想在函数前加 Math. 时，则需要 include Math 这段代码。

求正弦时使用 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。

变量

变量是程序里不可缺少的元素之一。可以将其理解为给对象贴上的标签。

我们可以像下面这样给对象贴上标签

变量名 = 对象

我们称这个过程为“将对象赋值给变量”。

alphabet = "abcdefg"
num = 10
age = 18
name = 'TAKAHASHI'

为了说明如何使用变量，让我们看看以下这个求长方体表面积和体积的例子

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 的值嵌入到字符串中。在字符串里使用 #{...} 这样的写法，可以把通过计算后得到的值嵌入到字符串中。输出结果里除了可以嵌入变量名，也可以嵌入 "表面积 = #{(xy + yz + z*x) * 2}\n" 这样的计算公式，得到的输出结果是一样的。

一般向屏幕输出结果时，我们都希望同时输出换行符，因此使用 puts 方法时，连 \n 也都不需要了，这样程序会变得更加简洁。

puts "表面积 = #{area}"

注释

我们在程序里可以写注释。注释虽然写在程序里面，但程序并不会执行注释的内容，也就是说，注释的内容对程序的执行结果不会产生任何影响。

大家也许会问：“为什么会在程序里写这种与程序运行无关的东西呢？”的确，对于只执行一次就可以的简单程序，并不需要特别的注释。但是，一般来说，我们都会多次使用写好的程序。那么，若希望记录程序的名称、作者、发布条件等信息，程序说明等内容时，就需要用到注释。

Ruby 用 # 表示注释的开始。某行是以 # 开头时，则整行都是注释。某行中间出现 # 时，则 # 以后部分就都是注释。另外，行的开头用 =begin 和 =end 括起来的部分也是注释。这样的注释方法，在程序开头或结尾写长说明时会经常用到。

=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 中使行的某部分成为注释的写法，只要是以 # 开始的部分，到行末为止一定都是注释。

控制语句

编程语言中都有控制语句。

控制语句能让程序在某种条件下，改变执行顺序，或者只执行某一部分。

控制语句的分类

控制语句大致可以分成以下几类。

顺序控制：按照程序的编写顺序，从头到尾执行。
条件控制：若某条件成立，则执行 ○○，否则执行 ××。
循环控制：在某条件成立之前，反复执行 ○○。
异常控制：发生某种异常时，执行 ○○。

顺序控制是程序最常见的处理方式。若不做特殊处理，程序会按照代码的编写顺序执行。

条件控制，是指根据条件执行分支处理。如果没有满足条件，程序会跳过某部分处理，继续执行其他处理。在 Ruby 中，可使用的条件判断语句有 if、unless、case 等。

循环控制，是指根据条件反复执行某个处理。在这种情况下，该处理的执行顺序会与程序编写的顺序不同，执行过一次的程序，会从头再执行一次。

异常控制有点特殊。程序执行时，意料之外的错误发生后，就会跳出正在执行的那部分程序，然后执行其他地方的程序，使程序能继续执行下去。根据实际情况，有时也会让程序马上结束。

接下来，我们进一步介绍条件控制和循环控制。

条件判断：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

那么，接下来让我们来看一下如何使用这些运算符编写条件语句。

一个简单的程序：变量 a 大于等于 10 时输出 bigger，小于 9 时输出 smaller。

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

循环

有时，我们会遇到希望多次循环执行同样的处理的情况。下面，我们来介绍两种执行循环处理的方法。

while 语句

while 语句是执行循序时用到的一种基本语句。同样地，do 关键字可以省略。

while 循环条件 do
　希望循环的处理
end

按顺序输出从 1 到 10 十个数字

i = 1
while i <= 10
  print i, "\n"
  i = i + 1
end

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 方法。

PreviousSpeed-Ruby Next入门2 对象