nbtymm

输入输出

　　在所有的本系列文章中，在编写Ruby代码时都使用了大量的Ruby标准输出方法。其中，最为常用的是print和puts方法，有关其使用细节不再赘述。

　　所有这些和其它处理输入和输出的方法都定义于Kernel模块中。这个Kernel模块又被包含在Object类中。因此，Kernel的方法出现在每一个对象中。在输出方面，Kernel定义了print，printf，putc和IO类和两个子类(File和BasicSocket)-它们允许读写文件和套接字。BasicSocket是套接字库的一部分并且将在以后讨论它。包含了FileTest模块的File类，提供了许多方法来操作系统文件和目录。从Kernel中使用的用于读写到标准输入/输出机制的方法被进一步重用于File实例中的读写操作。下面是一个代码示例-它把一些名字写入一个新建的文件中，然后再把这些名字读回到一个数组中。

customers=%w[Jim Kevin Davin Andrew] outFile = File.new("c:\\examples\\test\\customers.txt"， "w") customers.each{|customer| outFile.puts(customer)} outFile.close inFile= File.new("c:\\examples\\customers.txt"， "r") readCustomers=inFile.readlines readCustomers.each{|customer| puts customer} inFile.close

　　标准库

　　Ruby除了提供大量内置的类和模块外，它还提供了一定数目的标准库。这些库不是自动地成为你可以利用的Ruby类，模块，方法的一部分。你必须先在你的文件的顶部使用require(或load)关键字来使用库中的类或模块。在前一节中，我曾提到一个库-套接字库，它包含了大量的Ruby类(包括BasicSocket)，以便于访问网络服务。但是在Ruby下载中一同提供了一整套其它的库。你可以查看一下你的Ruby下载中的lib目录，这个目录下应该存在大量的你的Ruby程序需要使用的库。

　　有关这些库的不好的一点是，没有大量的有关于这些类的参考文档。你可以在网站http://www.ruby-doc.org/stdlib/上找到一系列标准库及其包含类和模块的文件。即使是这些文档也指出:

　　"你需要明白，在表格中粗体的库具有良好的文档，而斜体的库没有文档。"

　　这就是Ruby的现状。你可能想说，Ruby是一个不可思议地丰富而有力的语言并且内置了许多构建我们的应用程序需要的功能，但是文档仍然有点不足。还好，现在已经有不少的人在努力改进Ruby的文档和支持。现在有不少的Ruby论坛已经倔起，并且随着每一个新版本的发行，文档都将有一定的改进-当然，这也是最近它备受关注的结果。然而，帮助文档仍然会成为这种语言挫败人心的一个因素。

 在Ruby中，一切都是对象。更精确地说，Ruby中的一切都是一个具有完整功能的对象。因此，在Ruby中，数字4，定点数3.14和字符串"Hi"都是对象。显然，它们是有点"特殊"的，因为你不必使用new方法来创建它们。代之的是，你使用例如"literal 4"这样的形式来创建一个代表数字4的对象的实例。

　　然而，对于绝大多数人来说，学习一种新的编程语言时，首先理解该语言提供的"标准"类型是非常有用的。所以，在这一节，我们先探讨数字类型，字符串类型，布尔类型和另外一些基本的Ruby数据类型。

　　数字类型

　　实质上，Ruby中的数字被分为整数和浮点数两大类。其中，整数又被进一步细分为"常规大小"的整数和大型整数。因为在Ruby中一切都是对象，所以整数和浮点数都是按类来定义的（见图1）。从图1看出，Numeric是所有数字类型的基类，Float和Integer类是Numeric的子类。Fixnum和Bignum都是Integer的子类型-它们分别定义了"常规大小"的整数和大型整数。

图1.Ruby的数字类型类继承图。

　　Literal用来描述这些类的实例。下面的在交互式Ruby外壳(irb)中的代码显示了Float，Fixnum和Bignum的literal实例。注意，可以在literal上进行方法调用(在此，是指类方法)。

irb(main):001:0> 3.class => Fixnum irb(main):002:0> 3.4.class => Float irb(main):003:0> 10000000000000000000.class => Bignum

　　还有另外一些语法用来创建数字类型，显示于下面的代码列表中。字母E可以用来描述以指数标志的数字。数字的前面加上0代表这是一个八进制数，加上0x代表这是一个十六进制数，而0b代表是一个二进制数。为清晰起见，下划线可以用作数字中的分隔符号。注意，当写literal时，不要用逗号作为分隔符号。在一些情况中，这实际上能生成一个数组，我们将在后面讨论。最后，在一个字符（或Ctrl或元字符的组合）前面的一个问号将会创建一个Fixnum的实例，相应于字符的ASCII字符/逃逸序列值。

< irb(main):001:0> 3.14E5 #指数标志 => 314000.0 irb(main):002:0> 054 #八进制 => 44 irb(main):003:0> 0x5A #十六进制 => 90 irb(main):004:0> 0b1011 #二进制 => 11 irb(main):005:0> 10_000 #10，000，用下划线隔开 => 10000 irb(main):006:0> i=10，000 #创建一个数组而不是10000 Fixnum => [10， 0] irb(main):007:0> i.class => Array irb(main):008:0> ?Z #Fixnum ASCII值 => 90 irb(main):009:0> ?Z.class => Fixnum irb(main):010:0> ?\C-s #Control-s的值ASCII => 19

　　Fixnum和Bignum实例间的真实差别是什么？Fixnum整数可以被存储在机器中的一个字(通常16，32或64位)中，但减去1个位；而Bignum实例是超出固定存储空间的整数。当然，作为开发者，你不必担心整数的大小（见下面的例子），由Ruby负责为你实现Fixnum和Bignum之间的自动转换！

irb(main):001:0> i=4 => 4 irb(main):002:0> i.class => Fixnum irb(main):003:0> i=i+100000000000000 => 100000000000004 irb(main):004:0> i.class => Bignum irb(main):005:0> i=i-100000000000000 => 4 irb(main):006:0> i.class => Fixnum

　字符串

　　在Ruby中，字符串是任意顺序的字节。通常，它们是一个字符序列。在Ruby中，可以使用一个literal或new方法来创建String类的实例。

irb(main):001:0> s1="Hello World" => "Hello World" irb(main):002:0> s2=String.new("Hello World") => "Hello World"

　　当然，String中定义了许多方法(和操作符)。另外，可以使用单引号或双引号来指定一个字符串。双引号情况下允许串中加入逃逸字符并能够嵌入待计算的表达式。在单引号串情况下，你看到的就是串中的实际内容。为了更好的理解，请看下列例子。

irb(main):001:0> str1='a \n string' => "a \\n string" irb(main):002:0> str2="a \n string" => "a \n string" irb(main):003:0> puts str1 a \n string => nil irb(main):004:0> puts str2 a  string => nil irb(main):005:0> 'try to add #{2+2}' => "try to add \#{2+2}" irb(main):006:0> "try to add #{2+2}" => "try to add 4" irb(main):007:0> this="that" => "that" irb(main):008:0> 'when single quote rights #{this}' => "when single quote rights \#{this}" irb(main):009:0> "double quote rights #{this}" => "double quote rights that"

　　请注意，在显示之前，双引号中的文本是如何被计算的，其中包括了逃逸符号(\n)和表达式(#{2+2})。

　　除了使用单引号和双引号来定义一个字符串literal外，在Ruby中，还有另外的方法可以表达literal。一个百分号和小写或大写字母Q可以用来表达一个字符串，分别相应于单引号或双引号风格。

irb(main):001:0> %q@this is a single quote string #{2+2} here@ => "this is a single quote string \#{2+2} here" irb(main):002:0> %Q@this is a double quote string #{2+2} here@ => "this is a double quote string 4 here"

　　注意，跟随在q%或Q%后面的字符分别定义了字符串literal的开始和结束。在本例中，@符号用作字符串开始与结束的限界符号。

　　还应该注意，Ruby并没有区分一个字符串和一个字符。也就是说，没有适用于单个字符的特定的类-它们仅是一些小的字符串。

      布尔类型

　　最后，让我们再看一下布尔类型。在Ruby中，有两个类用于表达布尔类型：TrueClass和FalseClass。每个这些类仅有一个实例(一个singleton)：也就是true和false。这些是可在Ruby的任何地方存取的全局值。还有一个类NilClass。NilClass也仅有一个实例nil-表示什么也没有。然而，在布尔逻辑中，nil是false的同义词。

irb(main):001:0> true|false => true irb(main):002:0> true&false => false irb(main):003:0> true|nil => true irb(main):004:0> true&nil => false

　　正规表达式

　　大多数程序语言中都使用正规表达式。基于许多脚本语言的Ruby也广泛地使用正规表达式。我的一个同事曾经说"正规表达式太复杂了。"换句话说，你需要花费一些时间来学习正规表达式。在本文中，你仅能一瞥Ruby正规表达式的威力。在程序开发中，你不必一定使用正规表达式，但是如果使用这种工具，你的编码将更为紧凑而容易。而且，如果你想成为一名Ruby大师，你必须要花费其它时间来研究它。
在下面的例子中，Ruby中的正规表达式是在Tiger或菲Phil之间定义的。

/Tiger|Phil/

　　现在你可以在一个条件或循环语句中使用带有一个匹配操作符("=~")的正规表达式来匹配或查找其它的字符串。

irb(main):001:0>  golfer="Davis" if golfer =~ /Tiger|Phil/ puts "This is going to be a long drive." else puts "And now a drive by " + golfer end => "Davis"

　　下面是另一个稍微复杂些的正规表达式：

/[\w._%-]+@[\w.-]+.[a-zA-Z]{2，4}/

　　你能够猜出这个表达式代表什么意思吗？它相应于一个电子邮件地址。这个正规表达式可以用来校验电子邮件地址。

irb(main):001:0>  emailRE= /[\w._%-]+@[\w.-]+.[a-zA-Z]{2，4}/ email = "jwhite@interechtraining.com" if email =~ emailRE puts "This is a valid email address." else puts "this is not a valid email address." end 这是一个有效的电子邮件地址。 irb(main):002:0> email = "###@spammer&&&.333" if email =~ emailRE puts "This is a valid email address." else puts "this is not a valid email address." end

 

　　这不是一个有效的电子邮件地址

图2把电子邮件正规表达式分解开来。你已看到，正规表达式语言是相当丰富的，但在此不多详述。有关正规表达式的更多信息请参考http://www.regular-expressions.info。

图2.电子邮件正规表达式

　　注意，在Ruby中正规表达式也是一种对象。在下面的代码示例中，一个正规表达式实例（派生自类Regexp）作为String方法的一个参数（gsub）以达到使用"glad"来替换和"happy"与"joy"之目的。

irb(main):001:0>  quote = "I am so happy. Happy， happy， joy， joy!" regx = /(h|H)appy|joy/ quote.gsub(regx， "glad") => "I am so happy. Happy， happy， joy， joy!" => /(h|H)appy|joy/ => "I am so glad. glad， glad， glad， glad!"

　　当你在正规表达式对象上使用=~操作符时，你能够得到例如匹配模式串的索引等信息。

irb(main):001:0> /Tiger|Phil/=~"EyeOfTheTiger" => 8

　　如果你曾编写过大量有关字符串的程序，你就会知道Ruby中的正规表达式是非常有力量的。因此，我建议在较深入地用Ruby开发你的第一个程序前，你应该全面地探讨一下Ruby中的正规表达式。当然，你可以参考本文相应的源码文件，其中包含了大量的正规表达式。

　　范围

　　在Ruby中，一个很不平常但是非常有用的概念就是范围（range）。一个范围是一个值序列。例如，字符a到z就可以定义在英语字母表中的所有的小写字母。另外一个范围的例子是整数1到10。一个范围能从任何类型的对象中创建，假定对象的类型允许使用Ruby的操作符(<=>)和succ方法进行比较。根据<=>操作符左边的操作数是否小于，等于或大于<=>操作符右边的操作数，<=>操作符将分别返回-1，0或+1。例如，"A"<=>"B"将返回-1。运行于整数4上的succ方法(4.succ)将返回5。

　　可以使用Range类的new方法或特殊的标志来创建一个范围。下面是在irb中分别使用括号和点速记标志创建的两个相同的范围（表示所有的大写字母）。

irb(main):001:0> r1=Range.new("A"，"Z") => "A".."Z" irb(main):002:0> r2=("A".."Z") => "A".."Z"

　　当创建一个范围时，必须指定开始值和结束值。在上面的情况中，A作为开始值，Z作为结束值。当创建一个范围时，你还可以指示是否这个范围应该包括或不包括末尾元素。默认情况下，如上例所示，范围包括末尾元素。为了排除结束元素，你可以使用new方法的排除参数（置为true）或如下所示的3个点的速记标志。

irb(main):001:0> r1=Range.new("A"，"Z"，true) => "A"..."Z" irb(main):002:0> r2=("A"..."Z") => "A"..."Z" irb(main):003:0> r1.include?"Z" => false irb(main):004:0> r2.include?"Z" => false

　　上面的示例中在范围上调用的include?方法显示是否其参数是范围的一个成员。上例中，"Z"不是范围的一个元素。这个方法还有一个与之等价的操作符"==="-它实现相同的功能。

irb(main):005:0> r2==="Z" =≫  false

　　范围被应用在Ruby编程的许多方面。它们有两种特定的使用：作为生成器（generator）和谓词（predicate）。作为一个生成器，在范围上的每个方法允许你遍历该范围中的每个元素；例如，你想确定在一个K字节范围中的实际字节数。下面在irb中运行的代码使用了一个范围作为K字节到字节的生成器。

irb(main):008:0>  kilobytes=(1..10) kilobytes.each{|x| puts x*1024} => 1..10 1024 2048 3072 4096 5120 6144 7168 8192 9216 10240

 

　　在Ruby中，条件逻辑范围可以被用作谓语（predicate），通常借助于操作符===的帮助。例如，你可以使用一个范围谓词来测试一个相对于有效的端口号（0～65535）和保留的端口号（0～1024，不包括1024）的整数参考。

irb(main):001:0>  proposedPort = 8080 validPorts=(0..65535) reservedPorts=(0...1024) if (validPorts === proposedPort) & !(reservedPorts === proposedPort) puts "Proposed port is ok to use." else puts "Proposed port is not allowed to be used." end => 8080 => 0..65535 => 0...1024

　　上例的结果是，建议的端口号可以使用。

　　另外，范围也可以用于存取数据结构（如数组和哈希表）中的元素。

 一些程序语言（如C++和CLOS）提供了多重继承机制：一个类可以继承自多个超类。例如，一个House可能继承自一个Building类（连同Office和Hospital类一起）和Residence类（连同Apartment类一起）。尽管多重继承可能成为一种语言强有力的特征，但是由于它会增加该语言的复杂性和歧义，因此许多面向对象语言都没有加入它。

　　Ruby支持单继承。然而，它还提供了mixin-它提供了多继承的许多特征。一个mixin是一种"模块"类型。为此，你必须首先理解在Ruby中模块的含义。

　　在Ruby中，模块是一种把方法和常数分组的方式。它与类相似，但是一个模块没有实例并且也没有子类。也许解释模块的最好方法是举一个例子。假定你正在开发一个制造业应用程序。该程序需要存取大量的科学公式和常数，那么你可以或者是创建一个通用类来把这些放在其中或者是创建一个模块。模块的优点在于，在存取其中的公式时，根本没有任何实例扰乱所带来的烦恼。

module Formulas ACCELERATION = 9.8 LIGHTSPEED = 299792458 def energy (mass) mass*(LIGHTSPEED**2) end def force (mass) mass*ACCELERATION end end

 

　　现在，这些公式方法和常数可以被任何数目的其它类或其自身所使用：

irb(main):046:0> Formulas.force(10) => 98.0 irb(main):047:0≫ Formulas::ACCELERATION =≫ 9.8

　　注意，为了调用一个模块方法或使用一个模块常数，你必须使用类似于调用一个类方法的标志。为了调用一个模块方法，你需要使用模块类名，后面跟着一个点，再跟着模块方法名。为了引用模块常数，你可以使用模块名，后面跟着两个冒号，再跟着常数名。

　　除了作为方法和常数的"公共"应用以外，模块还可以帮助定义多重继承。一个mixin是一个简单的"包括"有一个类定义的模块。当一个类包括一个模块时，所有的模块中的方法和常数都成为类的实例方法和常数。例如，假定上面定义的Formula模块作为一个mixin被添加到Rectangle类。为此，你要使用"include"关键字：

class Rectangle include Formulas end

 

　　现在，Rectangle的实例具有了它们可以使用的force和energy方法，并且Rectangle类能够访问常数ACCELERATION和LIGHTSPEED：

irb(main):044:0> class Rectangle irb(main):045:1> include Formulas irb(main):046:1> end => Rectangle irb(main):047:0> Rectangle.new(4，5).force(10) => 98.0 irb(main):048:0> Rectangle::LIGHTSPEED => 299792458

　　这意味着，mixin给Ruby中的类带来了许多多重继承的优点，却避开了多重继承中存在的问题。

　　十一、 控制流

　　象所有的程序语言一样，Ruby提供了一组控制流命令，这包括条件语句(if/else结构)，case语句和循环语句(do，while和for)，还提供了象Ada和Java等语言中的异常处理能力。下面是Ruby中的一些控制流语句的示例：

ifarea > 100 "big" else "small" end case height | when 1 | print "stubby\n" | when 2..10 #高度范围为2～10 | print "short\n" | when 10..20 #高度范围为2～10 | print "tall\n" | end aRect = Rectangle.new(4，6) while aRect.area < 100 and aRect.height < 10 aRect.doubleSize() end for element in [2， 9.8， "some string"， Math::PI] #遍历对象集合 print "The type is: " + element.type.to_s + "\n&" end

　　控制语句通常非常直接，但是如前面的case语句和for循环语句所显示的，Ruby借鉴了其它一些语言特征和普通的面向对象的特性。
异常处理类似于Java中的"try...catch...finally"语句。在Ruby中，它们更改为"begin...rescue...ensure"语句：

begin #实现一些事情 rescue ##处理错误 ensure #做一些清理工作，如关闭一个打开的文件等 end

　　为了在你的代码中引发一个异常，你只需要简单地调用raise方法：

if area < 0 raise else if area > 0 and area < 10 raise "Rectangle too small" else if area > 100 raise TooBigException "Rectangle too big" end

　　第一个raise调用创建一个RuntimeError。第二个raise创建一个显示一条消息的RuntimeError。最后一个raise调用一个TooBigException的新实例（由它创建一个粗略定义的错误），并设置它的适当消息。

　　一个Ruby小程序

　　为了帮助你更好地掌握Ruby的基础知识，我在本文中提供了一个小程序供你学习之用。为了使这个程序工作，你可以下载并把该文件解压到你的文件系统。之后，它将创建一个examples文件夹，在这个目录下共有9个Ruby代码文件（.rb文件）。本文中的代码就包含在这些文件中。另外，你会找到一个testShapes.rb文件，它是测试Ruby的Rectangle，Square和Circle对象的主文件。只需简单地打开一个命令提示符并运行testShapes.rb文件即可。

　　你将注意到，在testShapes.rb和另外一些代码中，文件以"require"再加上一个文件名开头（象rectangle.rb）。这是在你的Ruby程序中加入或使用来自于其它文件代码的Ruby标志。

　　总结

　　Ruby能否接管Java或C#而成为业界领先的现代软件开发语言？尽管Ruby可能变得十分流行，但我对此仍抱有怀疑态度。作为一名在业界摸爬滚打多年的专业人员，我对其偶然性并不感到惊讶，但我还是比较注重实效的。例如，我发现Smalltalk是一种比Java优越的高级语言，然而优越并不会总会赢。现代语言背后总存在大量的技术和市场方面的支持。库，开发工具包，框架，架构，连接器，适配器，支持平台，服务，知识库，能干的开发团队，等等，都会被配置到位以支持象Java这样的程序语言。并且，无论你喜欢与否，Sun和Microsoft主宰下的市场在未来一段时间内肯定还是开发环境的胜者。

　　那么，为什么还要探讨Ruby呢？作为一种Perl或Python脚本语言的代替（这正是它的最初目的）或快速原型开发工具，Ruby可能特别有用。一些人也已经看到了Ruby的威力，并且开始把Ruby作为一种伟大的方法进行编程教学。根据我的本地Ruby用户组的成员提供的信息，有一些人正在把它应用于测试生产系统。不仅如此，我将邀请你，就象Bruce Tate和Dave Thomas邀请我一样来探讨一下这种语言的力量和美丽之处。即使Ruby不会得到广泛使用，但是随着人们对它的逐渐认识和试用，它一定会找到适应自己的编程环境。

• 　　· Private：只能为该对象所存取的方法。
• 　　· Protected：可以为该对象和类实例和直接继承的子类所存取的方法。
• 　　· Public：可以为任何对象所存取的方法（Public是所有方法的默认设置）。

　　这些关键字被插入在两个方法之间的代码中。所有从private关键字开始定义的方法都是私有的，直到代码中出现另一个存取控制关键字为止。例如，在下面的代码中，accessor和area方法默认情况下都是公共的，而grow方法是私有的。注意，在此doubleSize方法被显式指定为公共的。一个类的initialize方法自动为私有的。

class Rectangle attr_accessor :height， :width def initialize (hgt， wdth) @height = hgt @width = wdth end def area () @height*@width end private #开始定义私有方法 def grow (heightMultiple， widthMultiple) @height = @height * heightMultiple @width = @width * widthMultiple return "New area:" + area().to_s end public #再次定义公共方法 def doubleSize () grow(2，2) end end

 

　　如下所示，doubleSize可以在对象上执行，但是任何对grow的直接调用都被拒绝并且返回一个错误。

irb(main):075:0> rect2=Rectangle.new(3，4) => #<Rectangle:0x59a3088 @width=4， @height=3> irb(main):076:0> rect2.doubleSize() => "New area: 48" irb(main):077:0> rect2.grow() NoMethodError: private method 'grow' called for #<Rectangle:0x59a3088 @width=8， @height=6> from (irb):77 from :0

　　默认情况下，在Ruby中，实例和类变量都是私有的，除非提供了属性accessor和mutator。

象大多数面向对象语言一样，Ruby类也允许定义类变量和方法。一个类变量允许在一个类的所有实例间共享单个变量。在Ruby中，两个@@号用于指示类变量。例如，如果你想要使一个BankAccount类的所有实例共享相同的利息率，那么该类可能被如下定义:

class BankAccount @@interestRate = 6.5 def BankAccount.getInterestRate() @@interestRate end attr_accessor :balance def initialize (bal) @balance = bal end end

　　如你所见，类变量必须在使用前初始化，并且就象实例变量一样，如果你想存取类变量的话，你需要编写存取器方法。在此，我定义了一个类方法来返回利息率。注意，类名和在getInterestRate前面的句号表示一个类方法。一个类方法，不管对于任何实例，其工作方式都是相同的-在此，是把相同的利息率返回到所有的BankAccount实例。为了调用类方法，你需要使用类名，就象它使用于类方法定义中一样:

irb(main):045:0> BankAccount.getInterestRate => 6.5

　　事实上，用于创建类实例的"new"方法就是一个类方法。因此，当你在程序中输入"Rectangle.new"时，你实际在调用new类方法-这是Ruby默认情况下所提供的。

　　继承

　　面向对象编程的原则之一是支持类层次结构。就象自然界中的事物分类一样，类允许从更为通用的类进行继承。面向对象编程的特征主要体现在方法和变量的使用上。例如，一个Square类继承Rectangle类的一些特征，如方法和变量。一个Square是一种更具体类型的Rectangle(高度和宽度相等的Rectangle实例)，但是它仍然有一个高度和宽度，也有一个面积(而且与矩形的计算方法相同)。在Ruby中，Square类可以使用下列定义创建:

class Square < Rectangle end

　　"<Rectangle"意味着，Square是Rectangle的一个子类，或反过来说，Rectangle是Square的一个超类。默认情况下，一个Square实例自动地拥有所有一个Rectangle所拥有的相同的属性和方法，包括height，width和area方法。为了确保Square实例的边长相等，你可以重载现有的Square的initialize方法：

class Square < Rectangle def initialize (size) @height = size @width = size end end

　　因为在Ruby中一切都是对象，所以Ruby中的一切几乎都派生自Object类。尽管这在所有类定义中都不是显式的（你不会看到<Object出现在定义中），但是的确所有的类都派生自Ruby的基类Object。知道这个事实后，你就会更容易地理解接下来要讨论的内容。

　　当编写你的应用程序时，你可以在一个类定义外定义方法。在本文开始，你已看到了一个并不是任何一个类的一部分的摄氏到华氏转换器方法。作为另外一个示例，下面是一个位于任何类之外的方法：

def feel? return "I feel fine." end

　　为了执行这个方法，只要输入该方法名，而不需要类或实例：

irb(main):042:0> feel? => "I feel fine."

　　此方法看似另外一种语言（如C）中的函数或过程。事实上，尽管这些方法看上去好象不属于任何类，但是这些方法却都是你已经添加到Object类上的方法，它（因为Object是所有类的超类）反过来也把这一方法添加到你的继承类上。因此，现在你可以在任何对象（如Square和Rectangle的实例）甚至一个类（如Rectangle类）上调用这个方法。

irb(main):043:0> sq1=Square.new(4) => #<Square:0x5a18b50 @width=4， @height=4> irb(main):044:0> rect1=Rectangle.new(5，7) => #<Rectangle:0x5a139a8 @width=7， @height=5> irb(main):045:0> sq1.feel? => "I feel fine." irb(main):046:0> rect1.feel? => "I feel fine." irb(main):047:0> Rectangle.feel? => "I feel fine."

变量与赋值

　　至此，你是否注意到前面所有的示例代码中都缺少某种东西?难道你必须输入常数，实例变量或类变量?绝对不是!这正是Ruby的真正面向对象的天性的一部分。为此，首先让我们看一下Ruby中以前的普通变量。至此，你已经创建了很多Rectangle实例，但是你并没有把它们保留多长时间。比方说，你想要把一个变量赋值给你创建的一个Rectangle实例:

myRectangle = Rectangle.new(4，5)

　　在Ruby中这是完全有效的代码，而且根本不需要另一行代码来把myRectangle类型化或声明为引用Rectangle的某种东西。在执行这一行代码以后，变量myRectangle就引用一个Rectangle的实例(高度和宽度值分别为4，5)。但是，这仅是一种在任何时刻都可以更改的对象引用，而与对象的类型无关(在Ruby中一切都是对象)。因此，下面的命令提示符行中，你可以容易地把myRectangle赋值给一个字符串:

irb(main):049:0< myRectangle=Rectangle.new(4，5) => #<Rectangle:0x587c758 @width=5， @height=4> irb(main):050:0< myRectangle="Jim's Rectangle" => "Jim's Rectangle"

　　你可以在许多其它程序语言(甚至包括象Java这样的面向对象的语言)中试验一下，并观察从你的IDE所产生的编译错误。

　　变量，实例变量，类变量，甚至还有"常量"其实都只是对象引用。它们引用对象，但是它们并不是对象本身。因此，它们可以被动态地改变，甚至引用另一种不同类型的对象。

　　因为这一灵活性，所以必须在Ruby中进行一些约定以帮助每个人都知道某个变量正为代码所使用。其实，你已经看到了其中之一(@符号，它意味着这是一个实例变量)。其它的变量，方法和类命名约定列于下表1中。

• 　　· 局部变量和方法参数以一个小写字母开头。
• 　　· 方法名字以一个小写字母开头。
• 　　· 全局变量以一个$开头。
• 　　· 实例变量以一个@开头。
• 　　· 类变量以两个@开头。
• 　　· 常数以一个大写字母开头(它们经常被指定全部大写)。
• 　　· 类和模块名以一个大写字母开头。

局部变量	全局变量	实例变量	类变量	常数	类名	方法名
aVar	$Var	@var	@@var	VAR	MyClassmy	Method
name	$debug	@lastName	@@interest	PI	Rectangle	area

　　表1.这个表包含了在Ruby编码约定下的相关示例。

　　操作符方法

　　现在，假定你想实现合并Rectangle类的实例或把它们添加到另一个Rectangle实例。你当然可以定义另外一个称为"add"的方法，这种选择利用了Ruby真正的面向对象的特征之一。然而，你还可以重载"+"运算符来适当地把两个Rectangle实例加起来。这个"+"方法(如4+5)，对Ruby来说，只是另外一个方法而已。由于只是"另外一个方法"，所以你可以给它增加一些功能来满足Rectangle类的需要。例如，你还可以定义"+"运算符来实现一个矩形面积加上另一个矩形面积。

def + (anotherRectangle) totalArea = area() + anotherRectangle.area() Rectangle.new(@height，totalArea/@height) end

　　在把这个方法添加到Rectangle类以后，你可以使用+方法调用来把两个Rectangle的实例相加:

irb(main):001:0> rect1=Rectangle.new(2，3) => #<Rectangle:0x58aa688 @width=3， @height=2> irb(main):002:0> rect2=Rectangle.new(3，4) => #<Rectangle:0x58a6ef0 @width=4， @height=3> irb(main):003:0> rect1+rect2 => #<Rectangle:0x58a4a60 @width=9， @height=2>

　　这正是操作符重载，对于那些使用过Agol，C++，Python和其它语言的用户来说，可能已经非常熟悉这个特征。

　　方法参数

　　至此，我们一直假定，传递给一个方法的参数个数是已知的。也许在其它语言中不可思议，但是Ruby的确允许你传递可变个数的参数并且以单个参数来捕获它们。为了创建一个可变长度的参数，只需要把一个星号(*)放在最后一个参数前面即可。这样，你就可以在Ruby中编写一个如下的多边形定义。

class Polygon def initialize (s1，s2，s3，*others) @sideOne = s1 @sideTwo = s2 @sideThree = s3 @otherSides = others end end

　　如下所示，你可以使用这个定义来创建一个三角形或一个六边形。

irb(main):009:0> poly1=Polygon.new(2，4，5) => #<Polygon:0x594db10 @otherSides=[]， @sideThree=5， @sideTwo=4， @sideOne=2> irb(main):010:0> poly2=Polygon.new(2，18，4，5，7，9) => #<Polygon:0x5948d58 @otherSides=[5， 7， 9]， @sideThree=4， @sideTwo=18， @sideOne=2>

　　在支持可变长度参数的同时，Ruby还允许定义一个方法参数的默认值(在调用者没有提供的情况下使用)。例如，下面是Rectangle类的一个更好的初始化表达。

def initialize (hgt = 1， wdth = 1) @height = hgt @width = wdth end

　　现在，在调用时如果省略了某参数，那么在定义中参数紧邻的赋值运算符担当一个缺省的赋值器。现在，当创建一新的矩形时，如果在调用时省略了宽度，那么一个适当的宽度也会被默认地提供:

irb(main):090:0> rect=Rectangle.new(2) => #<Rectangle:0x5873f68 @width=1， @height=2>

在Ruby中，一切都是对象。对于那些喜欢使用高度面向对象的语言（例如Smalltalk，Eiffel或CLOS）的用户来说，这是非常受欢迎的。例如1，2，3或10.8等等都是对象，而不是如Java或C++中的原始类型；字符串是对象，类和方法也都是对象。例如，下面都是有效的Ruby代码(在Ruby中，注释行是以"#"符号界定的)：

#对象-34的绝对值 -34.abs #对一个浮点数进行四舍五入处理 10.8.round #返回一个字符串对象的大写且逆转的副本 "This is Ruby".upcase.reverse #返回数学sin方法的参数个数 Math.method(:sin).arity

 

图5.Ruby是全对象化的：在Ruby中，整数，浮点数，字符串，甚至类和方法都是对象。这里的代码展示了针对这些类型对象的方法调用。

　　在Ruby中，所有功能都是通过调用对象上的方法（或操作）实现的。事实上，Ruby中的方法调用就象其它程序语言中的函数或过程调用一样。

　　就象在所有面向对象程序语言中一样，对象是从类中创建的。Ruby库中提供了许多预构建的类。你可以修改这些类或构建你自己的类。Ruby中的类是使用"class"关键字定义的。类名开始是一个大写字母。类定义以"end"关键字结束。因此，一个Rectangle类的定义可能有如下形式：

class Rectangle end

　　为了把方法添加到类，可以使用def关键字。方法的定义也应该以end关键字结束。跟随def关键字和方法名后面就是方法参数。把一个area方法添加到上面的Rectangle类的代码看上去如下所示：

class Rectangle def area (hgt，wdth) return hgt*wdth end end

　　对于那些熟悉其它程序语言的用户，他可能注意到一些差别。Ruby并不使用任何花括号来限定类或方法，也不使用分号或其它字符来表示程序语句行的结束。Ruby的目标，根据它的创建者说明，是简单、易用并使编码成为一件"趣事"。谁想记住所有的那些分号？没有意思！在Ruby中，只要你把语句放在一行上，不需要分号或其它代码行结束标记。顺便说一下，在area方法参数周围的括号是不必要的。在默认情况下，Ruby返回一个方法中最后的内容，因此return关键字也可以省略。因此，你可以建立如下简单编码的Rectangle类：

class Rectangle def area hgt， wdth hgt*wdth end end

 

　　尽管上面代码是有效的，但是小括号还是被推荐使用于方法参数表达的，这主要是为了实现较好的可读性。

       实例变量和属性

　　类也可以有实例变量（在一些语言中也称为属性）。例如，由Rectangle类创建的对象应该都有一个高度和宽度。在Ruby中，实例变量不必显式地在类中声明，只是必须在它们的命名中以一个特殊字符来标记和使用。具体地说，所有的实例变量名都以"@"开头。为了实现当调用area方法时，存储矩形实例的高度和宽度，你仅需把实例变量添加到area方法即可：

class Rectangle def area (hgt， wdth) @height=hgt @width = wdth @height*@width end end

 

　　更确切地说，当创建一个Rectangle实例时，应该指定高度和宽度，而实例变量在此时才确定。另外，Ruby提供了一种特殊的方法initialize，它允许你建立或准备类的新实例：

class Rectangle def initialize (hgt， wdth) @height = hgt @width = wdth end def area () @height*@width end end

为了创建一个新的Rectangle对象或实例，你要调用标准的Ruby类构造器方法"new"：

Rectangle.new(4，7)

 

　　或，你可以使用没有括号的形式：

Rectangle.new 4，7

 

　　这个例子创建了一个新的Rectangle对象并且调用了initialize方法，其中传入参数4和7。注意，在下面的代码中添加了height和width方法以便共享高度和宽度信息：

class Rectangle def initialize (hgt， wdth) @height = hgt @width = wdth end def height return @height end def width return @width end def area () @height*@width end end

 

　　同样，为了使另外某个方法能够更新或设置一个Rectangle对象的高度和宽度，需要定义其它一些设置方法：

class Rectangle def initialize (hgt， wdth) @height = hgt @width = wdth end def height return @height end def height=(newHgt) @height=newHgt end def width return @width end def width=(newWdth) @width=newWdth end def area () @height*@width end end

 

　　译者注 本文中的mutator和accessor相当于其它语言中的setter和getter。

　　上面的mutator方法（"height="和"width="）可能看起来有点神秘，但是它们确实只是一些方法。不要让命名中的等号蒙骗了你。在方法名最后的额外字符对于Ruby并不意味着什么，但是它提高了代码的可读性。请看下列代码：

aRectangle.height=27

 

　　在此，一个Rectangle对象的高度正被赋值（改变）。事实上，这仅是一个对Rectangle对象的"height="方法的调用。

　　因为授予到一个对象的实例变量的存取权限非常普通，所以Ruby提供了一组关键字来实现一次性定义实例变量和accessor/mutator方法，从而使这些实例变量成为"public"属性。这些关键字是attr_reader，attr_accessor。它们有助于极大地简化代码：

class Rectangle attr_accessor :height， :width def initialize (hgt， wdth) @height = hgt @width = wdth end def area () @height*@width end end

 

　　在上面的示例代码中，attr_accessor给出了Rectangle相应于height和width属性的getter和setter。

用交互式Ruby构建应用程序

　　现在，你已经知道如何构建一个简单的Ruby应用程序。为了展示Ruby解释器的交互性，让我们启动一个交互的Ruby帮助和控制台工具（使用Ruby安装的fxri工具），见图6。

图6.启动fxri：从Windows开始菜单中打开交互式Ruby工具fxri。

　　在窗口的右下方是一个交互式的Ruby命令提示符（即"irb(main):001:0>"），它在窗口打开时显示出来。你可以进入到irb命令提示符行中并输入"Rectangle.new(6，5).area()"。之后，你应该看到如下结果：

irb(main):013:0> Rectangle.new(6，5).area() => 30

 

　　简洁有力！

　　在Ruby中，类从来不关闭。这意味着，你总是可以在一个现有类上添加或重定义方法。例如，你还可以在你创建的Rectangle类上添加一个circumference方法。在命令提示符上，请逐行输入下列代码：

class Rectangle def circumference () @height * 2 + @width * 2 end end

 

图7.输入Rectangle类：把Rectangle类的定义输入到fxri交互式Ruby解释器中，见图中的右下方。

　　Rectangle类又被定义了一次？不，Ruby解释器知道你正在修改当前的Rectangle类，它把一个新方法添加到现有Rectangle类中。现在，在命令提示符上输入下列一行："Rectangle.new(2，3).circumference()"。你应该看到类似如下的结果：

irb(main):014:0> class Rectangle irb(main):015:1> def circumference() irb(main):016:2> @height * 2 + @width * 2 irb(main):017:2> end irb(main):018:1> end => nil irb(main):019:0> Rectangle.new(2，3).circumference => 10

 

　　为了重新定义Rectangle类中的任何方法，例如area方法，只需简单地重新输入具有新的area方法定义的类定义即可：

irb(main):020:0> class Rectangle irb(main):021:1> def area() irb(main):022:2> @height*2 irb(main):023:2> end irb(main):024:1> end => nil irb(main):025:0> Rectangle.new(6，5).area => 12

 

　　在上面的简单例子中，area方法被重新定义以便总是返回原来高度的2倍。

　　一个类永远不会被关闭的思想可以应用于你自己定义的类和该语言中的内嵌类中。为了说明问题，让我们把一个area方法添加到String类。在命令提示符中输入下列代码：

class String def area() length() end end

 

　　现在，你在定义一个字符串的"area"方法以返回该字符串的长度。现在，你可以把你的名字作为一个字符串来试用一下这个新方法，见下面代码：

irb(main):026:0> class String irb(main):027:1> def area() irb(main):028:2> length() irb(main):029:2> end irb(main):030:1> end => nil irb(main):031:0> "Jim".area => 3

　　在本文示例中，我们使用Ruby的交互式特性及其开发环境来测试这种语言，而且我们仅使用了较小的代码片断。

　Ruby是一种面向对象的元编程语言，是它让许多开发者感到惊讶，甚至令他们提出这样的疑问:是否真正存在比Java和C#更好的语言?本文将对Ruby语言作初步的探讨并试图回答这一问题。

　　一、 引言

　　你是否听说过Ruby?如今，它成了软件开发界的一个流行话题。该语言在去年春天的一次Java会议上引起我的注意，当时象Bruce Tate，Dave Thomas等著名人物都在谈论Ruby并且告诉在场的观众Ruby值得一看。

　　现在，如果你象我一样正在从事软件开发，那么我们就有共识:尽管学习一种新的编程语言可能是一件趣事，但是只有你对它具有深入了解之后，你才有资格以一种怀疑眼光来看待另一种编程语言。毕竟，在上世纪八、九十年代的编程语言之争最终得出结论-从根本上看存在两大阵营:Java世界和微软基于.NET支持的开发语言。并不是我不想学习另一种语言，其实我只是期望通过选择其它编程语言才能获得一定技术优势的日子早点结束。然而，由于前面几位著名人士的影响，我决定一试Ruby。

　　好，假定"我已经到过山顶"，那么本文就是我对Ruby的研究报告。

　　二、 安装Ruby

　　Ruby是一种开源的编程语言，由日本的Yukihiro Matsumoto在九十年代中期开发。你可以在www.ruby-lang.org站点得到Ruby。这种语言最初被作为一种脚本语言创建，可应用于许多平台上，包括Linux、各种类UNIX、MS-DOS、Windows、BeOS、Amiga、Acorn Risc OS和MacOS X。当前Ruby的最新版本是1.8.4。对于使用Windows平台的用户，你可以点按这里来得到一个"one-click"型Windows安装程序。随同基本的Ruby二进制文件和库文件，这一下载中还包含一些有用的(并且是免费的)IDE和工具，包括帮助文档和示例代码，RubyGems包管理器，FreeRIDE(免费的Ruby IDE)，Fox GUI库，fxri(一种搜索引擎和Ruby文档的GUI指南，还有一个交互式命令行工具)和SciTE(Scintilla文本编辑器IDE)。在写本文时，Windows安装程序所提供的Ruby的"稳定"版本是1.8.2，还有一个1.8.4版本的预览版。注意，本文中的示例代码是用Windows安装程序所提供的1.8.2版本编写的。

　　使用Windows安装程序安装Ruby是相当直接的事情。你只要下载并运行一个简单的可执行安装文件(ruby182-15.exe)，这个程序就会启动一个标准的安装向导。下载文件大约有15MB，在向导把Ruby安装到Windows平台上后占大约40MB的硬盘空间。

　　对于那些偏爱自己的编辑器的程序员，大量的编辑器都提供了对Ruby的支持，包括emacs，vim，JEdit，Jed，Nedit和Textpad。当然，还有著名的Ruby Eclipse工程。Ruby开发工具(RDT)是一种Eclipse插件，当前仍处于早期开发中，但是你可以从此处下载试用它。另外，市场上还有一些便宜的Ruby IDE，Arachno Ruby就是其中之一。

　　运行Ruby

　　就象许多解释性语言一样，Ruby提供给程序员多种开发代码的方法。你可以使用命令行工具以交互方式运行Ruby或者创建一个Ruby程序文件，然后要求Ruby的解释器执行此程序。

　　在Windows中，打开命令行提示符窗口，在提示符上输入"Ruby"并回车(注意:你应该能够使系统沿Ruby的\bin目录找到Ruby可执行文件)。那么，Ruby就会运行并等候你输入程序。输入下面的程序，然后按Ctrl+D再按回车键，你就会看到Ruby执行你的程序，如图1所示。

def convertCtoF (celsius) print(celsius.to_s + " degrees celsius is " + ((celsius * 9)/5 + 32).to_s + " degrees in fahrenheit\n") end convertCtoF(20)

　　图1.在Ruby中以交互方式运行摄氏到华氏温度转换计算

　　图1中的转换程序也可以用一种Ruby IDE或简单文本编辑器实现并保存到一个文件中-例如convertCtoF.rb(.rb是Ruby程序的常用文件类型)。现在，Ruby解释器将执行这个文件中的Ruby程序，见图2。

　　图2.运行convertCtoF.rb

　　那些熟悉Smalltalk，Common Lisp Object System(CLOS)，或其它解释性编程环境的用户肯定都会熟悉交互的开发环境。交互特点允许你用小块编程代码进行试验。通过使用一个特殊的Ruby批处理文件irb.bat，你就能够克服Ruby解释器的非交互性特征。图3显示了使用irb.bat命令启动的Ruby。现在，代码可以被逐行地输入，解释和测试。

　　图3.交互式Ruby

　　交互式Ruby特征也被嵌入到若干工具中。例如，Ruby文档的图形接口fxri，不仅可作为一种语言指南，而且可以用作一种交互式Ruby解释器(见图4)。

　　图4.fxri的交互式Ruby能力:在此，fxri也用来运行和图3相同的Ruby命令，但这是从文档工具内部运行的。