[转帖][注意][分享]我见过的最好的Ruby入门教材

Tiger

我见过的最好的Ruby入门教材，是一个叫夏克的人写的，由于当时激动(我用的是复制)未记下网址，所以本文的转载无法经过夏克的同意，这里说声对不住了，希望有人能给个地址，大家上他那去看看！


什么是RGSS
--------------------------------------------------------------------------------

RGSS：

RGSS (Ruby Game Scripting System),中文意思就是：Ruby游戏脚本系统，是一个脚本性质的游戏编程系统，并不是整个游戏都用它来生成，

RGSS所能做的只是一些有限的功能，而这些功能，是由厂家也就是EnterBrain所规定的，我们只能在自己力所能及的范围内来挖掘RGSS的潜力

。
脚本（Script）:

脚本这个概念应用的范围很广，Windows系统里就有VBScript,JavaScript,WScript等脚本程序，Unix系统也有很多Perl,C等脚本程序，脚本可

以解释为是一种系统内用来实现一些特定功能的有着局限性的编程环境。有的脚本可以触及到系统底层，有的却只是完成一些运算或者控制流

程的功能，这取决于脚本系统的权限，也可以说取决于脚本系统所提供的库函数功能。

RGSS中的脚本：

在RMXP中，按F11就可以打开[脚本编辑器]，左边的窗口是脚本列表，右边的窗口是脚本内容，左下角可以修改脚本名称。

在RMXP中，游戏开始运行后，总是从最上边的脚本开始运行，依次往下，所以，经常把变量声明、类声明、函数声明、函数定义的脚本放在上

面，而MAIN脚本总是放在最后。

[此贴子已经被作者于2004-10-4 16:58:57编辑过]

Tiger

开始：最简单的脚本
--------------------------------------------------------------------------------

一个最简单的脚本：

我们建立一个新的游戏工程来从头学习RGSS，按[CTRL+N]新建工程，在[文件夹名]中键入TEST，按确定，建立新游戏TEST。
按F11调出[脚本编辑器]，用鼠标把第一个脚本Game_Temp选中，按DEL键删除它，一直按DEL键删除所有的脚本，只剩下Main脚本，然后右键点

Main脚本，选择[插入]来插入一个新的脚本，给新脚本命名为Test，删除Main脚本，点[确定]。这样我们就得到了一个空的脚本系统，试着运

行一下游戏，可以看到游戏在短暂的启动后就自动终止了，这表明没有任何脚本可以执行，游戏只好退出。

下面我们在Test脚本中加入一些内容。

按F11打开[脚本编辑器]，因为我们只有Test一个空脚本，所以在Test的内容中输入下面的代码：

ｐ \"欢迎使用RGSS来进行编程..\"

把这行代码复制并粘贴在Test脚本中，按[确定]，按F12，保存后游戏开始运行，短暂停顿后就会弹出一个对话框，内容是不是：\"欢迎使用

RGSS来进行编程..\"！这样我们就做出了第一个最简单的脚本。

需要注意的是：p要小写，这是因为RGSS是区分大小写的，如果你用P，你可以试试看能不能得到正确的结果。

脚本的注释：
用#号来表示注释，#号后面的代码不会被执行。

ｐ \"欢迎使用RGSS来进行编程..\"??? #这里是注释，不会被显示

把这行代码复制到Test脚本中，运行脚本，观察结果看到注释是不会被执行的。

Tiger

数据类型：数字
--------------------------------------------------------------------------------

数字：

数字包括整数和小数，小数在计算机术语中被称为浮点数，相信大家都明白什么是整数和小数了。整数包括正整数和负整数，0可以被视为整数

。常见的数字有：
1        整数
100      整数
-10      整数
0        整数
0.11     浮点数
-12.3    浮点数

数字属于常量的一部分。

我们写一个脚本来学习如何显示一个常量的值：

在Test脚本中，清除脚本内容，输入下面的代码：

p 100

运行脚本，看到弹出的对话框显示：100

若输入：

p 100.100

会弹出什么呢，你想想，实际上弹出的是100.1，而不是100.100。

数字的计算：

输入：

p 1+1

运行脚本，看到弹出的对话框显示：2。这就是常量的加法。你可以很聪明地想象出乘法、除法、减法：

输入：

p 3+5
p 3*5

p 3/5

p 3-5


运行脚本后看到，显示的是运算后的结果。注意到p 3/5一句显示的是0，这是因为：

整数和整数的运算，其结果仍旧表现为整数，如果你希望得到浮点数，那么就应该使被除数或者除数至少有一个是小数形式的表示。请看下面

的代码：

p 3.0/5
p 3/5.0


显示的结果就都是小数了。

值得一提的是还有两个很有用的算符，求余数和乘方：

求余数%：

输入：

p 14%4

结果显示2。

乘方**：

输入：

p 2**3

结果显示8。

括号的用处：

各种运算符之间总会存在优先顺序，加减乘除的顺序是不变的，对于其它你所不熟悉的或者弄不清除的，只要记住一点就可以了，那就是括号

的优先权是最高的，善用括号能够至少确保程序的准确性而先不管是不是很难看。

Tiger

数据类型：常量与变量
--------------------------------------------------------------------------------

常量：
常量就是我们经常会用的数字、字符串了，比如我们问一张光盘多少钱，回答说5元，那么5就是常量，如果说一张光盘的价格不定，在3-5元的

范围内浮动，那么这就是我们学过的未知数，对于这样的未知数我们经常会用一个变量来表示。

变量：

变量就是我们用一个符号来表示一个我们想要表示的概念，比如我们可以用price这个变量来表示一张光盘的价格。变量与常量的区别就在变量

是可以变动的，也就是说我们用变量来定义一个概念后，接下来就会来操作这个变量使它变化。而我们不能让一个常量变化，比如我们不能让

5=4，但我们可以让price=4。

变量的命名：

变量的取名有以下的限制：

1、必须以英文字母（大小写均可）、汉字、下划线开头。

2、第二个字符开始可以使用数字、英文字母、汉字、下划线。

3、不能使用保留字作变量的名字。

保留字是保留给系统用的，也就是说系统已经占用了，以下是系统的保留字：

alias def false nil return unless

and do for not self until

begin else if or super when

break elsif in redo then while

case end module rescue true yield

class ensure next retry undef

不要使用上面列出的单词做你的变量的名字。

变量的赋值：

变量无需事先声明，可以拿来就用，例如

ａ=100
p a


运行脚本，看到弹出的对话框显示：100

但必须先赋值才可以使用变量，否则，试试下面的代码：

p b

会弹出什么呢，如果不赋值给变量，就相当于这个变量不存在，而一旦赋值给它，就表明这个变量存在了。

变量的运算：

下面的代码你应该可以猜出是什么结果的：

战斗前的体力=234
战斗后的体力=200

p 战斗前的体力

p 战斗后的体力


继续：

p 战斗前的体力-战斗后的体力

看到了吗，这里我进行了运算，变量的运算。

就像对于常量一样，加减乘除和括号同样适用于变量的运算：

x=1
y=2

z=3

p x+(y*z)/(y+z)-y+z


但下面的运算是常量所没有的：

自运算：

x+=5
y*=2

z/=3

p x

p y

p z


+=,-=,*=,/=这四个运算符是自运算符，x+=1相当于x=x+1,其它同理。

全局变量：

局部变量和全局变量的区别在于局部变量只能被所在的脚本访问，而全局变量能被所有的脚本访问。

在变量名前加$符号就可以声明全局变量了。

Tiger

数据类型：字符串
--------------------------------------------------------------------------------

显示字符串：
先看看下面这几行语句在RGSS中的效果：

p\"这将会显示双引号\"
p\'这也会显示双引号\'

print\"这不会显示双引号\"

print\'这也不会显示双引号\'


把上面的四行语句复制下来，然后在我们刚刚建立好的Test脚本中粘贴，粘贴前最好把Test脚本的内容清除掉，我们只需要测试我们现在的代

码。好，运行游戏，看看效果吧。

首先，看得出来，用来输出显示的方法又多了一种：print，不同的是，p可以显示很多种数据类型，对不同的数据类型，它会按人们容易理解

的格式来显示，比如说这里的字符串，它都会加上双引号来告诉人们：这次显示的是字符串，而print直接显示字符串本身。

在上面的代码中，分别输出下面的四行字符串：

\"这将会显示双引号\"

\"这也会显示双引号\"

这不会显示双引号

这也不会显示双引号

　

字符串常量：

字符串常量的表示有两种方法。

1.双引号表示的字符串：

这种表示方法使得字符串可以支持一些特殊格式，这将是我们用的最多的表示方法，下面会有更详细的介绍。

2.单引号表示的字符串：

直白的说，单引号所包括的字符串会被原样显示出来，也就是说，即使单引号中包含特殊格式，也不会显示这种特殊格式。

　

字符串变量：

和数字变量一样，看看例子吧：

1、赋值：

a=\"欢迎使用RGSS来编程\"

print a


结果输出：欢迎使用RGSS来编程

2、连接：

a=\"中华人民\"
b=\"共和国\"

print a+b


结果输出：中华人民共和国

3、乘法：

a=\"连续两遍\"
print a*2


结果输出：连续两遍连续两遍

4、换行符：

\\n表示换行，但是只能用在双引号字符串内，若是在单引号字符串内便不起作用了，看看下面两个例子：

a=\'中华人民\\n共和国\'

b=\"中华人民\\n共和国\"

print a

print b


结果输出：

中华人民\\n共和国

中华人民
共和国

5、常量中包含变量：

a=\"人民\"

print \"中华#{a}共和国\"


结果输出：中华人民共和国

记住：这个特殊格式和\\n一样只能在双引号形式的字符串中使用。

再看一个：

a=\"C:\\\\Program Files\\\\RPG Maker XP\\\\System\\\\Data\\\\Skills.rxdata\"

print \"系统安装后的初始脚本文件是：#{a}\"


你可以试试看下面的例子：

a=\"人民\"

print \'中华#{a}共和国\'


结果#输出：中华#{a}共和国

Tiger

控制语句：条件分歧语句
--------------------------------------------------------------------------------

比较运算符：
有6个比较运算符,分别是

== 相等

!= 不相等

< 小

> 大

<= 小或相等

>= 大或相等

比较运算符，顾名思义，就是用来比较的，比较的对象可以是任意的，比较的结果是True或者False。

举例：

p(\" 早安 \"==\" 早安 \") # => true
p(\" 早安 \"==\" 晚安 \") # => false

p (3 + 1 == 3 + 5) # => false

p (3 + 1 == 2 + 2) # => true


观察一下结果就会明白。

逻辑运算符：

逻辑运算符也有6个，分别是：

与：and , &&

或：or , ||

非：not , !

举例：

p (100 > 77 and 1 + 1 == 2) # => true
p (100 > 77 && 1 + 1 == 2) # => true


if..elseif..else..end 语句：

结构：

if 条件1
   语句1
elseif 条件2
       语句2
     .
     .
else
       语句
end

举例：

x=123
y=23

z=67

a=(x*y*z+x/y+z/y)*(y-z)+x*z

if a>0

  print \"大于0\"

elseif a=0

  print \"等于0\"

else

  print \"小于0\"

end


最常用的还是if...end语句：

金钱数=10
if 金钱数<100

   print \"对不起，你的钱不够了..\"

end


unless..end 语句：

这是if..end语句的变种，正好跟if..end相反,就是除非的意思：

unless 条件

  语句

end

举例：

金钱数=10
unless 金钱数>=100

   print \"对不起，你的钱不够了..\"

end


除非你的金钱数大于等于100，否则：“对不起，你的钱不够了..”

case..when..end 语句：

如果对于把条件限制在某个范围或者某些特定的值的情况，使用case..end语句更方便：

case 变量

when 特定的值或者范围

when 特定的值或者范围

.

.

end

举例：

主角状态=\"昏睡\"
case 主角状态

when \"昏迷\"

   print \"你昏迷了..\"

when \"中毒\"

   print \"你中毒了..\"

when \"昏睡\"

   print \"你昏睡了..\"

end


条件赋值语句：

条件赋值语句给我们提供了一个非常方便的if..else..end的简化版。

(条件1 ? 语句1 : 语句2)

相当于：

if 条件1

   语句1

else

   语句2

end

举例：

战斗状态=1
print (战斗状态>0 ? \"胜利\" : \"失败\")

Tiger

控制语句：循环
--------------------------------------------------------------------------------

while..end 循环：
举例：

a = 0
i = 1

while i <= 5

a += i

i += 1

end

p a


这很简单，很容易明白的。

for..in..end 循环：
类似于c语言中的for,但不同，in后面给出变量的变化范围。

变化范围：

类似于1..5表示一个变化范围，其所含的值为大于等于1小于等于5。

举例：

a = 0
for i in 1..5

a += i

end

p a


这也很简单，很容易明白的。

loop do..end 循环：

举例：

i = 0
loop do

i += 1

p i

end


上面的代码会一直循环下去，也就是说是个死循环。只有使用break才可以从中跳出。

break 语句：
上面的例子如果改成下面的样子，就不再是死循环了：

i = 0
loop do

i += 1

   if i == 5

      break

   end

p i

end


break也可以从while、for循环中跳出。

next 语句：

跳过本次循环，进入下次循环。

举例：

for i in 1..5
if i == 3

next

end

p i

end


结果显示四次，就只有1 ， 2 ， 4 ， 5被显示出来了。

Tiger

函数
--------------------------------------------------------------------------------

函数的概念：
我们把事先编好的，能够解决或者说处理某种情况的功能的集合叫做函数。不必在意概念，用得多了自然就明白。其实我们一直在使用的

p,print就是函数的一种，下面介绍一个很有用的函数，随机函数rand()：

rand(x)返回0-(xx-1)范围内的随机数，例如：

p rand(100)

返回的数字在0-99范围内。

我们也可以设计自己的函数以便增加我们需要的功能，更多的时候，我们大多数时间是在跟函数打交道。

函数的声明：

函数的名字基本上和变量的名字有着相同的限制，例外的情况是，函数可以在名字的最后添加?或!符号，这种符号有着特殊的用处，以后会讲

到。

函数的声明要用def..end语句，形如：
def 函数名字
语句
end

我们用rand函数来设计一个自己的函数bet()：

def bet
  if rand(6)>3
     return \"大\"
  else
     return \"小\"
  end
end
print bet


这里的return表示函数返回的值，如果省略return也可以，但最好带上，能够使程序可读性更好。

我们给bet函数增加参数：

def bet(x)
  if rand(x)>3
     return \"大\"
  else
     return \"小\"
  end
end
print bet(7)


还可以为参数设置默认值:

def bet(x=7)
  if rand(x)>3
     return \"大\"
  else
     return \"小\"
  end
end
print bet   #这和print bet(7)一样


函数可以有很多参数：

def bet(x,y,z)
if rand(x)>3 and rand(y)>3 and rand(z)>3
return \"大\"
else
return \"小\"
end
end
print bet(7,6,10)



重定义函数：

如果定义了两次相同的函数，则只有后面定义的函数有效，而先前的定义就无效了。

def hello
return\" 您好 \"
end

def hello
return\" 晚安 \"
end

p hello #=>\" 晚安 \"

Tiger

PS1:不用再去研究破解Scripts.rxdata了，因为RGSS完全支持load,require语句。

在脚本中输入：

load \"d:/sequh.rb\"

就可以加载D盘的sequh.rb文件了，同理：

require \"D:/sequh.rb\"

这里我输入的是绝对路径，绝对路径的表示方法是：

把DOS格式的路径名中的“\\”统统改为“/”即可

而相对路径的获得，需要一点儿办法：

因为在我的游戏目录下有game.exe文件，所以我们可以通过它来获得游戏目录，然后得到绝对目录，把我们的相对路径加到绝对目录后面，例

子：

load  \"#{File.dirname(File.expand_path(\"Game.exe\"))}/scripts/sequh.rb\"

其中的File.dirname(File.expand_path(\"Game.exe\"))便是游戏目录的绝对路径。






PS2对 Ruby 变量、引号、数组、对象以及方法的介绍
Joshua D. Drake (jd@commandprompt.com)
项目经理，Command Prompt, Inc.
2001 年 7 月

这一四部分系列的第一篇是关于 Ruby 编程的介绍，由 Joshua Drake 执笔，他还撰写了 Linux Networking HOWTO、Linux PPP HOWTO 和

Linux Consultants HOWTO，同时还是定向开发 Linux 的公司 Command Prompt，Inc. 的共同创始人之一。那些了解如何使用其它诸如 Perl

之类的脚本语言的读者将会从本系列中获益最多。Joshua 从讨论变量、引号、数组、对象和方法开始探讨 Ruby。这一 Ruby 系列中的后几篇

文章将会涉及更多高级的课题，包括开发图形化应用程序以及和数据库一起使用 Ruby。
从介绍中可以知道，Ruby 是一种纯粹的面向对象的脚本语言，它由日本的 Yukihiro Matsumoto 开发。设计这种语言主要是用来控制文本处理

和系统管理任务。

正如下面的示例所示，任何曾经编写过如 Perl 或 PHP 等脚本语言的人都会熟悉 Ruby 语法。但是，Perl 或 PHP 需要使用分号作为一个行结

束符，Ruby 与它们不同，它不需要行结束符。某些开发者起先可能会对此感到有些困惑，不过我发现这实际上加速了开发的过程。例如，我再

也不会收到“Error missing ; on line x”的消息了。为了对 Ruby 世界有一个初步的了解，并阐述这个思想，请看一个经典的 Hello World

示例：

清单 1. Hello world

#!/usr/bin/ruby # # My first ruby program # print \"Hello World\\n\"



变量
Ruby 语言中的变量非常容易处理。让我们扩展第一个示例，并引入一个改变输出的简单方法。

清单 2. 改变输出

#!/usr/bin/ruby # # My first ruby program # # Declare our salutation $salut = \"Good Bye World\\n\" # Prepare statements print

\"Hello World\\n\" print $salut



使用 $salut 变量，我们可以随时轻易地改变第二个 print 语句的输出。您可以在程序的任何地方声明变量。

清单 3. 声明变量

#!/usr/bin/ruby # # My first ruby program # $salut = \"Good Bye World\\n\" print \"Hello World\\n\" print $salut # # Declare a new

value for $salut. # $salut = \"Oh, I am sorry. I didn\'t mean to warn you...\\n\" print \"What do you mean Good Bye World?\\n\"

print $salut



如果执行上述示例，将会输出以下内容：


Hello World Good Bye World What do you mean Good Bye World? Oh, I am sorry. I didn\'t mean to warn you...



正如您看到的那样，变量的重新赋值生效了。

单引号和双引号
像大多数语言一样，Ruby 区分双引号和单引号。在 Ruby 语言中，双引号表示 Ruby 将解释包含在引号内的任何值。例如：

print \"Hello World\\n\"


Ruby 解释器将转义 \\n 并打印一个换行符到 STDOUT（标准输出）。但是，如果我们要执行带单引号的同样语句，例如：

print \'Hello World\\n\'


Ruby 将输出如下内容：

Hello World\\n


注意新的一行没有被打印。取而代之的是 Ruby 把整个语句看作了文字，这和 Perl 使用的功能一样。

单词算术
在 Ruby 语言中，所有字符串都可以使用操作符。这就意味着在某种意义上我们可以对单词进行算术运算。例如：

$salut = $salut * 3


将会产生如下结果：

Oh, I am sorry. I didn\'t mean to warn you... Oh, I am sorry. I didn\'t mean to warn you... Oh, I am sorry. I didn\'t mean to

warn you...


而

$salut = $salut + \" 10, 9, 8...\" print $salut


将会生成如下结果：

Oh, I am sorry. I didn\'t mean to warn you... Oh, I am sorry. I didn\'t mean to warn you... Oh, I am sorry. I didn\'t mean to

warn you... 10, 9, 8...


注意到尽管变量打印了三次，但是 \"10, 9, 8...\" 的串联只在程序最后打印了一次。为什么会这样？

原因是我们只把 \"10, 9, 8...\" 添加到了变量的末尾。我们并没有要求变量将 \"10, 9, 8...\" 添加到每一行。另外，注意对变量的当前使用

的继承性也很重要。

一旦给一个变量赋了值，除非再重新赋值，否则它就一直是静态的，正如示例中我们将 $salut 从 \"Hello World\\n\" 改为等于 \"What do you

mean Good Bye World? \\n\"。但是，当变量进行乘法和串联操作时情况就不是这样了。您可以从上一个示例看出，对变量使用串联（+ 符号）

将会导致这个变量继承它早先的赋值加上添加到它的赋值上的字符串。在我们的示例中，添加的字符串是 \"10, 9, 8...\"。

数组
如果知道将多次对 $salut 变量赋值，您会怎样做呢？这在很多情况下都会发生。因此，您可以将所有的变量值放进一个数组里，而不是手动

地给变量重新赋值。

数组允许对每个变量值进行分别的处理。请看如下示例：

$salut = [\'Hello World\',\'Good Bye World\',\'What do you mean Good Bye World?\'] print $salut


运行上述代码得到的输出如下所示：

Hello WorldGood Bye WorldWhat do you mean Good Bye World?


显然，这不是我们想要的输出。没有间隔也没有换行。因此，我们可以标识希望显示数组的哪一部分，并使用先前解释的串联技术来更方便地

提供易读的输出。

$salut = [\'Hello World\',\'Good Bye World\',\'What do you mean Good Bye World?\'] print $salut[0] + \"\\n\" print $salut[1] + \"\\n\"

print $salut[2] + \"\\n\"


将会导致如下输出：

Hello World Good Bye World What do you mean Good Bye World?


仔细分析这些代码。如果回顾一下我们建立的数组：

$salut = [\'Hello World\',\'Good Bye World\',\'What do you mean Good Bye World?\']


我们告诉 Ruby 定义一个名为 salut 的变量，其值为：

$salut  =  0  1  2  
Hello World Good Bye World What do you mean Good Bye World?

每个值通过一个数字来被识别。数字通过数组中的数字位置来定义。位置总是从 0 开始，并从 0 开始递增。所以要打印数组中的第 2 个值，

您要输入：

print $salut[1]


最容易忘记的是字段从 0 而不是从 1 开始。

条件 — IF，ELSE
我们已经探讨了用 Ruby 语言显示数据的基础知识。现在来看 Ruby 编程中有关逻辑的初步知识。也就是说，让我们根据从程序员那里获得的

结果来指示 Ruby 程序执行基本功能。我们还要根据 Ruby 程序从用户那里获得的结果看如何执行条件语句。在这些示例中将使用新的代码。

清单 4. 根据结果执行基本功能

$salut = [\'Hello World\',\'Good Bye World\',\'What do you mean Good Bye World?\'] print \"When you enter the world, what do you

say? \" while enterWorld = STDIN.gets enterWorld.chop! if enterWorld == $salut[0] print \"\\n\" + \"Yes. Hello World would be

polite.\\n\" break else print \"You say \'\", enterWorld, \"\'?!\\n\" + \"You humans are so rude!\\n\" end end



上面的代码段引入了 Ruby 开发的几个新的方面，让我们浏览这些片段。

按部就班地浏览我们的示例

#!/usr/bin/ruby # # My first interactive ruby script # # Define our main variable with an array $salut = [\'Hello World\',\'Good

Bye World\',\'What do you mean Good Bye World?\'] # Print my first question print \"When you enter the world, what do you say? \"

# Create a while loop with the object enterWorld and await data from # standard input. The while loop will make sure that

ruby continues # to process the application until the program tells it to stop. while enterWorld = STDIN.gets # Make sure we

use the chop method on the enterWorld object. The use # of the chop method will insure that we strip new lines and carriage #

returns from our input. # You will notice that using the chop method has an extra # character. The ! allows the existing

object to be modified # by the method. If you did not use the !, you would have to redeclare # the enterWorld object for the

if condition to correctly occur. enterWorld.chop! # Begin the condition sequence. Basically, if enterworld equals # Hello

World, which is 0, within the array, print # a new line. Then print, \"Yes, Hello World would be polite.\" to the screen. if

enterWorld == $salut[0] print \"\\n\" + \"Yes. Hello World would be polite.\\n\" # The break statement tells ruby to stop executing

if the previous # condition is met. If we did not include this in our while loop, # the program would run continuously. break

# The else statement is used as the secondary condition. In other # words, if the first condition is not met, please do the

following. else print \"You say \'\", enterWorld, \"\'?!\\n\" + \"You humans are so rude!\\n\" break # The end statement is used to

close a condition or loop. In our case, # it is being used to close both. We are first closing our if # condition statements

and then stopping our while loop. end end



对象和方法
这个代码段中用到的一些技术和方法您可能是第一次见到。Ruby 是一种面向对象的编程（Object Oriented Programming，OOP）语言。使用

OOP 时，通常情况下程序员将调用诸如对象和方法之类的项目。对象就象一个容器。它包含自己特定的变量和函数。 方法是一种被调用的东西

，就像函数对对象进行专门处理一样。如果看一下先前的示例，我们就可以显示工作中的对象和方法。

while enterWorld = STDIN.gets enterWorld.chop!


这里我们有两个对象和两个方法的示例。第一个对象是 enterWorld，第二个对象是 STDIN。enterWorld 对象是用户定义的对象，而 STDIN 对

象（Standard Input 的缩写）是 Ruby 内建的。

这个示例中还有两种方法。第一种是 gets，第二种是 chop!。前面提到过，方法对对象进行专门处理。明确地说，方法将在对象中执行一个操

作。用 gets 方法，我们告诉 Ruby 去获取 STDIN。当 Ruby 看到与 STDIN 关联的 gets，它就会等待键盘输入和一个回车。简而言之，

STDIN.gets 就是等待用户输入一些内容然后敲 Enter 键。

第二种方法 chop! 用来对用户定义的对象 enterWorld 进行专门处理。chop! 方法告诉 enterWorld 将 enterWorld 对象关联的数据的换行符

和回车符截去。如果不使用 chop!（或者 chomp!），那么包含在先前代码上下文中的下面语句永远都不会为真。

if enterWorld == $salut[0]


因为没有使用 chop!，所以得出结果将为假，$salut[0] 实际上就等于 $salut[0]\\n。新行是由 STDIN 对象从 gets 方法接收的输入产生的。

使用回车将会在值末尾添加一个换行符。

结论
Ruby 是一种非常强大而且易于使用的语言。如果您是一个出身于 C++、 Perl 或 Python 的程序员，您会发现它们与 Ruby 有一些极为相似之

处（尤其是 Python 语言）。这个系列的下一篇文章将会基于这篇介绍讨论一些更高级的课题，比如使用 Roby 模块以及文件操作。

参考资料

关于更多的 Ruby 基础知识，包括对于 Ruby 创建者 Yukihiro Matsumoto 的采访，请参阅 developerWorks 上的 “Ruby: A new language”

。


请参阅官方的 Ruby Web 站点。


请访问 Ruby 园地。


在 Ruby 详细说明中学习更多有关 Ruby 的知识。


查找更多关于 Ruby for Win32 的内容。


请在 Ruby Central 驻足。


请查阅 Ruby 应用档案，这是用 Ruby 维护的。


请参阅 Ruby 功能的简单列表，其中包含关于 Ruby 优缺点的简短讨论（英文版和德文版）。


请参阅 FileWatcher.org 的最新 Ruby 文件更新情况。


请阅读面向 Windows 用户的 Ruby。


请访问 Joshua Drake 的 Web 站点 Command Prompt。


请在 developerWorks 浏览更多的 Linux 参考资料。


请在 developerWorks 浏览 更多的开放源代码参考资料。


关于作者
Joshua Drake 是 Command Prompt, Inc（一个定向开发 PostgreSQL 和 Linux 的公司）的共同创始人之一。他当前还撰写 Linux Networking

HOWTO、Linux PPP HOWTO 和 Linux Consultants HOWTO，他这段时间最要紧的项目是为 O\'Reilly 写一本新的 PostgreSQL 方面的书 —

Practical PostgreSQL。请通过 jd@commandprompt.com 与他联系。

小得蛇

呃...完全看不懂... ≥_≤