谁适合阅读本教程？

本教程有助于初学者理解 Ruby 语言基础知识及基本概念。

阅读本教程前，您需要了解的知识：

在您开始练习本教程中提供的各种实例之前，最好已经对计算机程序和计算机程序设计语言有一个基本的认识，这将有助于您对本教程的学习。

编译/执行 Ruby 程序

对于大多数编程语言，第一个入门实例便是 "Hello World!"，下面的实例使用 Ruby 输出 "Hello World!"：

点击"运行实例"按钮查看在线实例运行结果。

或者是在irb交互式命令行的模式下：

>>puts "Hello, world!"Hello, world!=> nil

Ruby是一种纯粹的面向对象编程语言。它由日本的松本行弘（まつもとゆきひろ/Yukihiro Matsumoto）创建于1993年。

您可以在 www.ruby-lang.org 的 Ruby 邮件列表上找到松本行弘（まつもとゆきひろ/Yukihiro Matsumoto）的名字。在 Ruby 社区，松本也被称为马茨（Matz）。

Ruby 是"程序员的最佳朋友"。

Ruby 的特性与 Smalltalk、Perl 和 Python 类似。Perl、Python 和 Smalltalk 是脚本语言。Smalltalk 是一个真正的面向对象语言。Ruby，与 Smalltalk 一样，是一个完美的面向对象语言。使用 Ruby 的语法比使用 Smalltalk 的语法要容易得多。

Ruby 的特性

• Ruby 是开源的，在 Web 上免费提供，但需要一个许可证。
• Ruby 是一种通用的、解释的编程语言。
• Ruby 是一种真正的面向对象编程语言。
• Ruby 是一种类似于 Python 和 Perl 的服务器端脚本语言。
• Ruby 可以用来编写通用网关接口（CGI）脚本。
• Ruby 可以被嵌入到超文本标记语言（HTML）。
• Ruby 语法简单，这使得新的开发人员能够快速轻松地学习 Ruby。
• Ruby 与 C++ 和 Perl 等许多编程语言有着类似的语法。
• Ruby 可扩展性强，用 Ruby 编写的大程序易于维护。
• Ruby 可用于开发的 Internet 和 Intranet 应用程序。
• Ruby 可以安装在 Windows 和 POSIX 环境中。
• Ruby 支持许多 GUI 工具，比如 Tcl/Tk、GTK 和 OpenGL。
• Ruby 可以很容易地连接到 DB2、MySQL、Oracle 和 Sybase。
• Ruby 有丰富的内置函数，可以直接在 Ruby 脚本中使用。

您需要的工具

为了执行本教程中讨论的实例，您需要 RAM 至少为 2GB（推荐为 4GB）的 Intel Core i3 或 i5 的计算机。您还需要以下软件：

• Linux 或 Windows 95/98/2000/NT 或 Windows 7 操作系统
• Apache 1.3.19-5 Web 服务器
• Internet Explorer 5.0 或以上的 Web 浏览器
• Ruby 1.8.5

本教程将介绍如何使用 Ruby 创建 GUI、网络和 Web 应用程序。另外还会讨论如何扩展和嵌入 Ruby 应用程序。

接下来将学习什么？

下一章将向您介绍从哪里可以获取 Ruby 及其文档。最后，它会指示您如何安装 Ruby，并配置环境为开发 Ruby 应用程序做准备。

Ruby 环境

本地环境设置

如果您想要设置 Ruby 编程语言的环境，请阅读本章节的内容。本章将向您讲解与环境设置有关的所有重要的主题。建议先学习下面几个主题，然后再进一步深入学习其他主题：

• Linux/Unix 上的 Ruby 安装：如果您想要在 Linux/Unix 上配置开发环境，那么请查看本章节的内容。

• Windows 上的 Ruby 安装：如果您想要在 Windows 上配置开发环境，那么请查看本章节的内容。

• Ruby 命令行选项：本章节列出了所有的命令行选项，您可以和 Ruby 解释器一起使用这些命令行选项。

• Ruby 环境变量：本章节列出了所有重要的环境变量列表，设置这些环境变量以便让 Ruby 解释器工作。

流行的 Ruby 编辑器

为了编写 Ruby 程序，您需要一个编辑器：

• 如果您是在 Windows 上进行编写，那么您可以使用任何简单的文本编辑器，比如 Notepad 或 Edit plus。
• VIM（Vi IMproved）是一个简单的文本编辑器，几乎在所有的 Unix 上都是可用的，现在也能在 Windows 上使用。另外，您还可以使用您喜欢的 vi 编辑器来编写 Ruby 程序。
• RubyWin 是一个针对 Windows 的 Ruby 集成开发环境（IDE）。
• Ruby Development Environment （RDE） 对于 Windows 用户来说，也是一个很好的集成开发环境（IDE）。

交互式 Ruby（IRb）

交互式 Ruby（IRb）为体验提供了一个 shell。在 IRb shell 内，您可以逐行立即查看解释结果。

这个工具会随着 Ruby 的安装自动带有，所以您不需要做其他额外的事情，IRb 即可正常工作。

只需要在命令提示符中键入 irb，一个交互式 Ruby Session 将会开始，如下所示：

$irbirb 0.6.1(99/09/16)irb(main):001:0> def helloirb(main):002:1> out = "Hello World"irb(main):003:1> puts outirb(main):004:1> endnilirb(main):005:0> helloHello Worldnilirb(main):006:0>

这里您可以先不用关心上面命令的执行内容，我们将在后续的章节中向您讲解。

接下来将学习什么？

假设现在您已经设置好 Ruby 环境，且已经做好编写第一个 Ruby 程序的准备。下一章我们将向您讲解如何编写 Ruby 程序。

Ruby 安装 - Unix

下面列出了在 Unix 机器上安装 Ruby 的步骤。

注意：在安装之前，请确保您有 root 权限。

• 下载最新版的 Ruby 压缩文件。请点击这里下载。
• 下载 Ruby 之后，解压到新创建的目录下：

• $ tar -xvzf ruby-2.2.3.tgz    $ cd ruby-2.2.3

  • 现在，配置并编译源代码，如下所示：

  $ ./configure$ make$ sudo make install

  • 安装后，通过在命令行中输入以下命令来确保一切工作正常：

  $ruby -vruby 2.2.3……

• 如果一切工作正常，将会输出所安装的 Ruby 解释器的版本，如上所示。如果您安装了其他版本，则会显示其他不同的版本。

• 自动安装 Ruby

  如果您的计算机已经连接到 Internet，那么最简单安装 Ruby 的方式是使用 yum 或 apt-get。在命令提示符中输入以下的命令，即可在您的计算机上安装 Ruby。

  $  sudo yum install ruby    # CentOS, Fedora, 或 RHEL 系统或sudo apt-get install ruby-full # Debian 或 Ubuntu 系统

  如果你是苹果系统，可以使用 brew 命令安装：

  $ brew install ruby

下面列出了在 Windows 机器上安装 Ruby 的步骤。

注意：在安装时，您可能有不同的可用版本。

• Window 系统下，我们可以使用 RubyInstaller 来安装 Ruby 环境，下载地址为：请点击这里下载。
• 下载 rubyinstaller 之后，解压到新创建的目录下：
• 双击 rubyinstaller-2.2.3.exe 文件，启动 Ruby 安装向导。
• 点击 Next，继续向导，记得勾选 Add Ruby executables to your PATH，直到 Ruby 安装程序完成 Ruby 安装为止。

如果您的安装没有适当地配置环境变量，接下来您可能需要进行环境变量的配置。

• 如果您使用的是 Windows 9x，那么请在您的 c:autoexec.bat 中添加：set PATH="D:(ruby 安装目录)in;%PATH%"
• Windows NT/2000 用户需要修改注册表。
  • 点击控制面板|系统性能|环境变量。
  • 在系统变量下，选择 Path，并点击 EDIT。
  • 在变量值列表的末尾添加 Ruby 目录，并点击 OK。
  • 在系统变量下，选择 PATHEXT，并点击 EDIT。
  • 添加 .RB 和 .RBW 到变量值列表中，并点击 OK。

• 安装后，通过在命令行中输入以下命令来确保一切工作正常：

$ ruby -vruby 2.2.3

• 如果一切工作正常，将会输出所安装的 Ruby 解释器的版本，如上所示。如果您安装了其他版本，则会显示其他不同的版本。

Ruby 命令行选项

Ruby 一般是从命令行运行，方式如下：

$ ruby [ options ] [.] [ programfile ] [ arguments ... ]

解释器可以通过下列选项被调用，来控制解释器的环境和行为。

单字符的命令行选项可以组合使用。下面两行表达了同样的意思：

$ruby -ne 'print if /Ruby/' /usr/share/bin$ruby -n -e 'print if /Ruby/' /usr/share/bin

Ruby 环境变量

Ruby 解释器使用下列环境变量来控制它的行为。ENV 对象包含了所有当前设置的环境变量列表。

对于 Unix，使用 env 命令来查看所有环境变量的列表。

HOSTNAME=ip-72-167-112-17.ip.secureserver.netRUBYPATH=/usr/binSHELL=/bin/bashTERM=xtermHISTSIZE=1000SSH_CLIENT=122.169.131.179 1742 22SSH_TTY=/dev/pts/1USER=amroodJRE_HOME=/usr/java/jdk/jreJ2RE_HOME=/usr/java/jdk/jrePATH=/usr/local/bin:/bin:/usr/bin:/home/guest/binMAIL=/var/spool/mail/guestPWD=/home/amroodINPUTRC=/etc/inputrcJAVA_HOME=/usr/java/jdkLANG=CHOME=/rootSHLVL=2JDK_HOME=/usr/java/jdkLOGDIR=/usr/log/rubyLOGNAME=amroodSSH_CONNECTION=122.169.131.179 1742 72.167.112.17 22LESSOPEN=|/usr/bin/lesspipe.sh %sRUBYLIB=/usr/lib/rubyG_BROKEN_FILENAMES=1_=/bin/env

Ruby 语法

让我们编写一个简单的 Ruby 程序。所有的 Ruby 文件扩展名都是 .rb。所以，把下面的源代码放在 test.rb 文件中。

在这里，假设您的 /usr/bin 目录下已经有可用的 Ruby 解释器。现在，尝试运行这个程序，如下所示：

$ ruby test.rb

这将会产生下面的结果：

Hello, Ruby!

您已经看到了一个简单的 Ruby 程序，现在让我们看看一些 Ruby 语法相关的基本概念：

Ruby 程序中的空白

在 Ruby 代码中的空白字符，如空格和制表符一般会被忽略，除非当它们出现在字符串中时才不会被忽略。然而，有时候它们用于解释模棱两可的语句。当启用 -w 选项时，这种解释会产生警告。

实例：

a + b 被解释为 a+b （这是一个局部变量）a  +b 被解释为 a(+b) （这是一个方法调用）

Ruby 程序中的行尾

Ruby 把分号和换行符解释为语句的结尾。但是，如果 Ruby 在行尾遇到运算符，比如 +、- 或反斜杠，它们表示一个语句的延续。

Ruby 标识符

标识符是变量、常量和方法的名称。Ruby 标识符是大小写敏感的。这意味着 Ram 和 RAM 在 Ruby 中是两个不同的标识符。

Ruby 标识符的名称可以包含字母、数字和下划线字符（ _ ）。

保留字

下表列出了 Ruby 中的保留字。这些保留字不能作为常量或变量的名称。但是，它们可以作为方法名。

Ruby 中的 Here Document

"Here Document" 是指建立多行字符串。在 << 之后，您可以指定一个字符串或标识符来终止字符串，且当前行之后直到终止符为止的所有行是字符串的值。

如果终止符用引号括起，引号的类型决定了面向行的字符串类型。请注意<< 和终止符之间必须没有空格。

下面是不同的实例：

#!/usr/bin/ruby -w# -*- coding : utf-8 -*-print <<EOF    这是第一种方式创建here document 。    多行字符串。EOFprint <<"EOF";                # 与上面相同    这是第二种方式创建here document 。    多行字符串。EOFprint <<`EOC`                 # 执行命令	echo hi there	echo lo thereEOCprint <<"foo", <<"bar"	      # 您可以把它们进行堆叠	I said foo.foo	I said bar.bar

这将产生以下结果：

    This is the first way of creating    her document ie. multiple line string.    This is the second way of creating    her document ie. multiple line string.hi therelo there        I said foo.        I said bar.

Ruby BEGIN 语句

语法

BEGIN {   code}

声明 code 会在程序运行之前被调用。

实例

#!/usr/bin/rubyputs "This is main Ruby Program"BEGIN {   puts "Initializing Ruby Program"}

这将产生以下结果：

Initializing Ruby ProgramThis is main Ruby Program

Ruby END 语句

语法

END {   code}

声明 code 会在程序的结尾被调用。

实例

#!/usr/bin/rubyputs "This is main Ruby Program"END {   puts "Terminating Ruby Program"}BEGIN {   puts "Initializing Ruby Program"}

这将产生以下结果：

Initializing Ruby ProgramThis is main Ruby ProgramTerminating Ruby Program

Ruby 注释

注释会对 Ruby 解释器隐藏一行，或者一行的一部分，或者若干行。您可以在行首使用字符（ # ）：

# 我是注释，请忽略我。

或者，注释可以跟着语句或表达式的同一行的后面：

name = "Madisetti" # 这也是注释

您可以注释多行，如下所示：

# 这是注释。# 这也是注释。# 这也是注释。# 这还是注释。

下面是另一种形式。这种块注释会对解释器隐藏 =begin/=end 之间的行：

=begin这是注释。这也是注释。这也是注释。这还是注释。=end

Ruby 类和对象

Ruby 是一种完美的面向对象编程语言。面向对象编程语言的特性包括：

• 数据封装
• 数据抽象
• 多态性
• 继承

这些特性将在 面向对象的 Ruby 中进行讨论。

一个面向对象的程序，涉及到的类和对象。类是个别对象创建的蓝图。在面向对象的术语中，您的自行车是自行车类的一个实例。

以车辆为例，它包括车轮（wheels）、马力（horsepower）、燃油或燃气罐容量（fuel or gas tank capacity）。这些属性形成了车辆（Vehicle）类的数据成员。借助这些属性您能把一个车辆从其他车辆中区分出来。

车辆也能包含特定的函数，比如暂停（halting）、驾驶（driving）、超速（speeding）。这些函数形成了车辆（Vehicle）类的数据成员。因此，您可以定义类为属性和函数的组合。

类 Vehicle 的定义如下：

Class Vehicle{   Number no_of_wheels   Number horsepower   Characters type_of_tank   Number Capacity   Function speeding   {   }   Function driving   {   }   Function halting   {   }}

通过给这些数据成员分配不同的值，您可以创建类 Vehicle 的不同实例。例如，一架飞机有三个轮子，马力 1,000，燃油罐容量为 100 升。以同样的方式，一辆汽车有四个轮子，马力 200，煤气罐容量为 25 升。

在 Ruby 中定义类

为了使用 Ruby 实现面向对象编程，您需要先学习如何在 Ruby 中创建对象和类。

在 Ruby 中，类总是以关键字 class 开始，后跟类的名称。类名的首字母应该大写。类 Customer 如下所示：

class Customerend

您可以使用关键字 end 终止一个类。类 中的所有数据成员都是介于类定义和 end 关键字之间。

Ruby 类中的变量

Ruby 提供了四种类型的变量：

• 局部变量：局部变量是在方法中定义的变量。局部变量在方法外是不可用的。在后续的章节中，您将看到有关方法的更多细节。局部变量以小写字母或 _ 开始。
• 实例变量：实例变量可以跨任何特定的实例或对象中的方法使用。这意味着，实例变量可以从对象到对象的改变。实例变量在变量名之前放置符号（@）。
• 类变量：类变量可以跨不同的对象使用。类变量属于类，且是类的一个属性。类变量在变量名之前放置符号（@@）。
• 全局变量：类变量不能跨类使用。如果您想要有一个可以跨类使用的变量，您需要定义全局变量。全局变量总是以美元符号（$）开始。

实例

使用类变量 @@no_of_customers，您可以判断被创建的对象数量，这样可以确定客户数量。

class Customer   @@no_of_customers=0end

在 Ruby 中使用 new 方法创建对象

对象是类的实例。现在您将学习如何在 Ruby 中创建类的对象。在 Ruby 中，您可以使用类的方法 new 创建对象。

方法 new 是一种独特的方法，在 Ruby 库中预定义。new 方法属于类方法。

下面的实例创建了类 Customer 的两个对象 cust1 和 cust2：

cust1 = Customer. newcust2 = Customer. new

在这里，cust1 和 cust2 是两个对象的名称。对象名称后跟着等号（=），等号后跟着类名，然后是点运算符和关键字 new。

自定义方法来创建 Ruby 对象

您可以给方法 new 传递参数，这些参数可用于初始化类变量。

当您想要声明带参数的 new 方法时，您需要在创建类的同时声明方法 initialize。

initialize 方法是一种特殊类型的方法，将在调用带参数的类的 new 方法时执行。

下面的实例创建了 initialize 方法：

class Customer   @@no_of_customers=0   def initialize(id, name, addr)      @cust_id=id      @cust_name=name      @cust_addr=addr   endend

在本实例中，您可以声明带有 id、name、addr 作为局部变量的 initialize方法。在这里，def 和 end 用于定义 Ruby 方法 initialize。在后续的章节中，您将学习有关方法的更多细节。

在 initialize 方法中，把这些局部变量的值传给实例变量 @cust_id、@cust_name 和 @cust_addr。在这里，局部变量的值是随着 new 方法进行传递的。

现在，您可以创建对象，如下所示：

cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")cust2=Customer.new("2", "Poul", "New Empire road, Khandala")

Ruby 类中的成员函数

在 Ruby 中，函数被称为方法。类中的每个方法是以关键字 def 开始，后跟方法名。

方法名总是以小写字母开头。在 Ruby 中，您可以使用关键字 end 来结束一个方法。

下面的实例定义了一个 Ruby 方法：

class Sample   def function      statement 1      statement 2   endend

在这里，statement 1 和 statement 2 是类 Sample 内的方法 function 的主体的组成部分。这些语句可以是任何有效的 Ruby 语句。例如，我们可以使用方法 puts 来输出 Hello Ruby，如下所示：

class Sample   def hello      puts "Hello Ruby!"   endend

下面的实例将创建类 Sample 的一个对象，并调用 hello 方法：

#!/usr/bin/rubyclass Sample   def hello      puts "Hello Ruby!"   endend# 使用上面的类来创建对象object = Sample. newobject.hello

这将会产生下面的结果：

Hello Ruby!

简单的案例研究

如果您想要做更多有关类和对象的练习，这里有一个案例研究：

Ruby 类案例

Ruby 类案例

下面将创建一个名为 Customer 的 Ruby 类，您将声明两个方法：

• display_details：该方法用于显示客户的详细信息。
• total_no_of_customers：该方法用于显示在系统中创建的客户总数量。

#!/usr/bin/rubyclass Customer   @@no_of_customers=0   def initialize(id, name, addr)      @cust_id=id      @cust_name=name      @cust_addr=addr   end   def display_details()      puts "Customer id #@cust_id"      puts "Customer name #@cust_name"      puts "Customer address #@cust_addr"    end    def total_no_of_customers()       @@no_of_customers += 1       puts "Total number of customers: #@@no_of_customers"    endend

display_details 方法包含了三个 puts 语句，显示了客户 ID、客户名字和客户地址。其中，puts 语句：

puts "Customer id #@cust_id"

将在一个单行上显示文本 Customer id，后跟变量 @cust_id 的值。

当您想要在一个单行上显示实例变量的文本和值时，您需要在 puts 语句的变量名前面放置符号（#）。文本和带有符号（#）的实例变量应使用双引号标记。

第二个方法，total_no_of_customers，包含了类变量 @@no_of_customers。表达式 @@no_of_ customers+=1 在每次调用方法 total_no_of_customers 时，把变量 no_of_customers 加 1。通过这种方式，您将得到类变量中的客户总数量。

现在创建两个客户，如下所示：

cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")cust2=Customer.new("2", "Poul", "New Empire road, Khandala")

在这里，我们创建了 Customer 类的两个对象，cust1 和 cust2，并向 new 方法传递必要的参数。当 initialize 方法被调用时，对象的必要属性被初始化。

一旦对象被创建，您需要使用两个对象来调用类的方法。如果您想要调用方法或任何数据成员，您可以编写代码，如下所示：

cust1.display_details()cust1.total_no_of_customers()

对象名称后总是跟着一个点号，接着是方法名称或数据成员。我们已经看到如何使用 cust1 对象调用两个方法。使用 cust2 对象，您也可以调用两个方法，如下所示：

cust2.display_details()cust2.total_no_of_customers()

保存并执行代码

现在，把所有的源代码放在 main.rb 文件中，如下所示：

#!/usr/bin/rubyclass Customer   @@no_of_customers=0   def initialize(id, name, addr)      @cust_id=id      @cust_name=name      @cust_addr=addr   end   def display_details()      puts "Customer id #@cust_id"      puts "Customer name #@cust_name"      puts "Customer address #@cust_addr"   end   def total_no_of_customers()      @@no_of_customers += 1      puts "Total number of customers: #@@no_of_customers"   endend# 创建对象cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")cust2=Customer.new("2", "Poul", "New Empire road, Khandala")# 调用方法cust1.display_details()cust1.total_no_of_customers()cust2.display_details()cust2.total_no_of_customers()

接着，运行程序，如下所示：

$ ruby main.rb

这将产生以下结果：

Customer id 1Customer name JohnCustomer address Wisdom Apartments, LudhiyaTotal number of customers: 1Customer id 2Customer name PoulCustomer address New Empire road, KhandalaTotal number of customers: 2

Ruby 变量

Ruby 全局变量

全局变量以 $ 开头。未初始化的全局变量的值为 nil，在使用 -w 选项后，会产生警告。

给全局变量赋值会改变全局状态，所以不建议使用全局变量。

下面的实例显示了全局变量的用法。

#!/usr/bin/ruby$global_variable = 10class Class1  def print_global     puts "Global variable in Class1 is #$global_variable"  endendclass Class2  def print_global     puts "Global variable in Class2 is #$global_variable"  endendclass1obj = Class1.newclass1obj.print_globalclass2obj = Class2.newclass2obj.print_global

在这里，$global_variable 是全局变量。这将产生以下结果：

注意：在 Ruby 中，您可以通过在变量或常量前面放置 # 字符，来访问任何变量或常量的值。

Global variable in Class1 is 10Global variable in Class2 is 10

Ruby 实例变量

实例变量以 @ 开头。未初始化的实例变量的值为 nil，在使用 -w 选项后，会产生警告。

下面的实例显示了实例变量的用法。

#!/usr/bin/rubyclass Customer   def initialize(id, name, addr)      @cust_id=id      @cust_name=name      @cust_addr=addr   end   def display_details()      puts "Customer id #@cust_id"      puts "Customer name #@cust_name"      puts "Customer address #@cust_addr"    endend# 创建对象cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")cust2=Customer.new("2", "Poul", "New Empire road, Khandala")# 调用方法cust1.display_details()cust2.display_details()

在这里，@cust_id、@cust_name 和 @cust_addr 是实例变量。这将产生以下结果：

Customer id 1Customer name JohnCustomer address Wisdom Apartments, LudhiyaCustomer id 2Customer name PoulCustomer address New Empire road, Khandala

Ruby 类变量

类变量以 @@ 开头，且必须初始化后才能在方法定义中使用。

引用一个未初始化的类变量会产生错误。类变量在定义它的类或模块的子类或子模块中可共享使用。

在使用 -w 选项后，重载类变量会产生警告。

下面的实例显示了类变量的用法。

#!/usr/bin/rubyclass Customer   @@no_of_customers=0   def initialize(id, name, addr)      @cust_id=id      @cust_name=name      @cust_addr=addr   end   def display_details()      puts "Customer id #@cust_id"      puts "Customer name #@cust_name"      puts "Customer address #@cust_addr"    end    def total_no_of_customers()       @@no_of_customers += 1       puts "Total number of customers: #@@no_of_customers"    endend# 创建对象cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")cust2=Customer.new("2", "Poul", "New Empire road, Khandala")# 调用方法cust1.total_no_of_customers()cust2.total_no_of_customers()

在这里，@@no_of_customers 是类变量。这将产生以下结果：

Total number of customers: 1Total number of customers: 2

Ruby 局部变量

局部变量以小写字母或下划线 _ 开头。局部变量的作用域从 class、module、def 或 do 到相对应的结尾或者从左大括号到右大括号 {}。

当调用一个未初始化的局部变量时，它被解释为调用一个不带参数的方法。

对未初始化的局部变量赋值也可以当作是变量声明。变量会一直存在，直到当前域结束为止。局部变量的生命周期在 Ruby 解析程序时确定。

在上面的实例中，局部变量是 id、name 和 addr。

Ruby 常量

常量以大写字母开头。定义在类或模块内的常量可以从类或模块的内部访问，定义在类或模块外的常量可以被全局访问。

常量不能定义在方法内。引用一个未初始化的常量会产生错误。对已经初始化的常量赋值会产生警告。

#!/usr/bin/rubyclass Example   VAR1 = 100   VAR2 = 200   def show       puts "Value of first Constant is #{VAR1}"       puts "Value of second Constant is #{VAR2}"   endend# 创建对象object=Example.new()object.show

在这里，VAR1 和 VAR2 是常量。这将产生以下结果：

Value of first Constant is 100Value of second Constant is 200

Ruby 伪变量

它们是特殊的变量，有着局部变量的外观，但行为却像常量。您不能给这些变量赋任何值。

• self: 当前方法的接收器对象。
• true: 代表 true 的值。
• false: 代表 false 的值。
• nil: 代表 undefined 的值。
• __FILE__: 当前源文件的名称。
• __LINE__: 当前行在源文件中的编号。

Ruby 运算符

Ruby 算术运算符

假设变量 a 的值为 10，变量 b 的值为 20，那么：

Ruby 比较运算符

假设变量 a 的值为 10，变量 b 的值为 20，那么：

Ruby 赋值运算符

假设变量 a 的值为 10，变量 b 的值为 20，那么：

Ruby 并行赋值

Ruby 也支持变量的并行赋值。这使得多个变量可以通过一行的 Ruby 代码进行初始化。例如：

a = 10b = 20c = 30

使用并行赋值可以更快地声明：

a, b, c = 10, 20, 30

并行赋值在交换两个变量的值时也很有用：

a, b = b, c

Ruby 位运算符

位运算符作用于位，并逐位执行操作。

假设如果 a = 60，且 b = 13，现在以二进制格式，它们如下所示：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

下表列出了 Ruby 支持的位运算符。

Ruby 逻辑运算符

下表列出了 Ruby 支持的逻辑运算符。

假设变量 a 的值为 10，变量 b 的值为 20，那么：

Ruby 三元运算符

有一个以上的操作称为三元运算符。第一个计算表达式的真假值，然后根据这个结果决定执行后边两个语句中的一个。条件运算符的语法如下：

Ruby 范围运算符

在 Ruby 中，序列范围用于创建一系列连续的值 - 包含起始值、结束值（视情况而定）和它们之间的值。

在 Ruby 中，这些序列是使用 ".." 和 "..." 范围运算符来创建的。两点形式创建的范围包含起始值和结束值，三点形式创建的范围只包含起始值不包含结束值。

Ruby defined? 运算符

defined? 是一个特殊的运算符，以方法调用的形式来判断传递的表达式是否已定义。它返回表达式的描述字符串，如果表达式未定义则返回 nil。

下面是 defined? 运算符的各种用法：

用法 1

defined? variable # 如果 variable 已经初始化，则为 True

例如：

foo = 42defined? foo    # => "local-variable"defined? $_     # => "global-variable"defined? bar    # => nil（未定义）

用法 2

defined? method_call # 如果方法已经定义，则为 True

例如：

defined? puts        # => "method"defined? puts(bar)   # => nil（在这里 bar 未定义）defined? unpack      # => nil（在这里未定义）

用法 3

# 如果存在可被 super 用户调用的方法，则为 Truedefined? super

例如：

defined? super     # => "super"（如果可被调用）defined? super     # => nil（如果不可被调用）

用法 4

defined? yield   # 如果已传递代码块，则为 True

例如：

defined? yield    # => "yield"（如果已传递块）defined? yield    # => nil（如果未传递块）

Ruby 点运算符 "." 和双冒号运算符 "::"

您可以通过在方法名称前加上模块名称和一条下划线来调用模块方法。您可以使用模块名称和两个冒号来引用一个常量。

:: 是一元运算符，允许在类或模块内定义常量、实例方法和类方法，可以从类或模块外的任何地方进行访问。

请记住：在 Ruby 中，类和方法也可以被当作常量。

您只需要在表达式的常量名前加上 :: 前缀，即可返回适当的类或模块对象。

如果未使用前缀表达式，则默认使用主 Object 类。

下面是两个实例：

MR_COUNT = 0        # 定义在主 Object 类上的常量module Foo  MR_COUNT = 0  ::MR_COUNT = 1    # 设置全局计数为 1  MR_COUNT = 2      # 设置局部计数为 2endputs MR_COUNT       # 这是全局常量puts Foo::MR_COUNT  # 这是 "Foo" 的局部常量 

第二个实例：

CONST = ' out there'class Inside_one   CONST = proc {' in there'}   def where_is_my_CONST      ::CONST + ' inside one'   endendclass Inside_two   CONST = ' inside two'   def where_is_my_CONST      CONST   endendputs Inside_one.new.where_is_my_CONSTputs Inside_two.new.where_is_my_CONSTputs Object::CONST + Inside_two::CONSTputs Inside_two::CONST + CONSTputs Inside_one::CONSTputs Inside_one::CONST.call + Inside_two::CONST

Ruby 运算符的优先级

下表按照运算符的优先级从高到低列出了所有的运算符。

注意：在方法列标识为 是 的运算符实际上是方法，因此可以被重载。

Ruby 注释

注释是在运行时会被忽略的 Ruby 代码内的注释行。单行注释以 # 字符开始，直到该行结束，如下所示：

当执行时，上面的程序会产生以下结果：

Hello, Ruby!

Ruby 多行注释

您可以使用 =begin 和 =end 语法注释多行，如下所示：

#!/usr/bin/ruby -wputs "Hello, Ruby!"=begin这是一个多行注释。可扩展至任意数量的行。但 =begin 和 =end 只能出现在第一行和最后一行。 =end

当执行时，上面的程序会产生以下结果：

Hello, Ruby!

请确保尾部的注释离代码有足够的距离，以便容易区分注释和代码。如果块中超过一条尾部注释，请对齐它们。例如：

@counter      # 跟踪页面被击中的次数@siteCounter  # 跟踪所有页面被击中的次数

Ruby 判断

Ruby if...else 语句

语法

if conditional [then]   code...[elsif conditional [then]    code...]...[else    code...]end

if 表达式用于条件执行。值 false 和 nil 为假，其他值都为真。请注意，Ruby 使用 elsif，不是使用 else if 和 elif。
如果 conditional 为真，则执行 code。如果 conditional 不为真，则执行 else 子句中指定的 code。
通常我们省略保留字 then 。若想在一行内写出完整的 if 式，则必须以 then 隔开条件式和程式区块。如下所示:

if a == 4 then a = 7 end

实例

#!/usr/bin/ruby# -*- coding: UTF-8 -*-x=1if x > 2   puts "x 大于 2"elsif x <= 2 and x!=0   puts "x 是 1"else   puts "无法得知 x 的值"end

尝试一下 »

以上实例输出结果：

x 是 1

Ruby if 修饰符

语法

code if condition

如果 conditional 为真，则执行 code。

实例

#!/usr/bin/ruby$debug=1print "debug
" if $debug

这将产生以下结果：

debug

Ruby unless 语句

语法

unless conditional [then]   code[else   code ]end

unless式和 if式作用相反，即如果 conditional 为假，则执行 code。如果 conditional 为真，则执行 else 子句中指定的 code。

实例

#!/usr/bin/rubyx=1unless x>2   puts "x 小于 2" else  puts "x 大于 2"end

这将产生以下结果：

x 小于 2

Ruby unless 修饰符

语法

code unless conditional

如果 conditional 为假，则执行 code。

实例

#!/usr/bin/ruby# -*- coding: UTF-8 -*-$var =  1print "1 -- 这一行输出
" if $varprint "2 -- 这一行不输出
" unless $var$var = falseprint "3 -- 这一行输出
" unless $var

这将产生以下结果：

1 -- 这一行输出3 -- 这一行输出

Ruby case 语句

语法

case expression[when expression [, expression ...] [then]   code ]...[else   code ]end

case先对一个 expression 进行匹配判断，然后根据匹配结果进行分支选择。

它使用 ===运算符比较 when 指定的 expression，若一致的话就执行 when 部分的内容。

通常我们省略保留字 then 。若想在一行内写出完整的 when 式，则必须以 then 隔开条件式和程式区块。如下所示:

when a == 4 then a = 7 end

因此：

case expr0when expr1, expr2   stmt1when expr3, expr4   stmt2else   stmt3end

基本上类似于：

_tmp = expr0if expr1 === _tmp || expr2 === _tmp   stmt1elsif expr3 === _tmp || expr4 === _tmp   stmt2else   stmt3end

实例

#!/usr/bin/ruby# -*- coding: UTF-8 -*-$age =  5case $agewhen 0 .. 2    puts "婴儿"when 3 .. 6    puts "小孩"when 7 .. 12    puts "child"when 13 .. 18    puts "少年"else    puts "其他年龄段的"end

这将产生以下结果：

小孩

Ruby 循环

Ruby while 语句

语法

while conditional [do]   codeend

或者

<pre>while conditional [:]   codeend

当 conditional 为真时，执行 code。

语法中 do 或 : 可以省略不写。但若要在一行内写出 while 式，则必须以 do 或 : 隔开条件式或程式区块。

实例

#!/usr/bin/ruby# -*- coding: UTF-8 -*-$i = 0$num = 5while $i < $num  do   puts("在循环语句中 i = #$i" )   $i +=1end

以上实例输出结果为：

Inside the loop i = 0Inside the loop i = 1Inside the loop i = 2Inside the loop i = 3Inside the loop i = 4

Ruby while 修饰符

语法

code while condition或者begin   code end while conditional

当 conditional 为真时，执行 code。

如果 while 修饰符跟在一个没有 rescue 或 ensure 子句的 begin 语句后面，code 会在 conditional 判断之前执行一次。

实例

#!/usr/bin/ruby# -*- coding: UTF-8 -*-$i = 0$num = 5begin   puts("在循环语句中 i = #$i" )   $i +=1end while $i < $num

尝试一下 »

以上实例输出结果为：

在循环语句中 i = 0在循环语句中 i = 1在循环语句中 i = 2在循环语句中 i = 3在循环语句中 i = 4

Ruby until 语句

until conditional [do]   codeend

当 conditional 为假时，执行 code。

语法中 do 可以省略不写。但若要在一行内写出 until 式，则必须以 do 隔开条件式或程式区块。

实例

#!/usr/bin/ruby# -*- coding: UTF-8 -*-$i = 0$num = 5until $i > $num  do   puts("在循环语句中 i = #$i" )   $i +=1;end

这将产生以下结果：

在循环语句中 i = 0在循环语句中 i = 1在循环语句中 i = 2在循环语句中 i = 3在循环语句中 i = 4在循环语句中 i = 5

Ruby until 修饰符

语法

code until conditional或者begin   codeend until conditional

当 conditional 为假时，执行 code。

如果 until 修饰符跟在一个没有 rescue 或 ensure 子句的 begin 语句后面，code 会在 conditional 判断之前执行一次。

实例

#!/usr/bin/ruby# -*- coding: UTF-8 -*-$i = 0$num = 5begin   puts("在循环语句中 i = #$i" )   $i +=1;end until $i > $num

这将产生以下结果：

在循环语句中 i = 0在循环语句中 i = 1在循环语句中 i = 2在循环语句中 i = 3在循环语句中 i = 4在循环语句中 i = 5

Ruby for 语句

语法

for variable [, variable ...] in expression [do]   codeend

针对 expression 中的每个元素分别执行一次 code。

实例

#!/usr/bin/ruby# -*- coding: UTF-8 -*-for i in 0..5   puts "局部变量的值为 #{i}"end

在这里，我们已经定义了范围 0..5。语句 for i in 0..5 允许 i 的值从 0 到 5（包含 5）。
尝试一下 »

以上实例输出结果为：

局部变量的值为 0局部变量的值为 1局部变量的值为 2局部变量的值为 3局部变量的值为 4局部变量的值为 5

for...in 循环几乎是完全等价于：

(expression).each do |variable[, variable...]| code end

但是，for 循环不会为局部变量创建一个新的作用域。

语法中 do 可以省略不写。但若要在一行内写出 for 式，则必须以 do 隔开条件式或程式区块。

实例

#!/usr/bin/ruby# -*- coding: UTF-8 -*-(0..5).each do |i|   puts "局部变量的值为 #{i}"end

以上实例输出结果为：

局部变量的值为 0局部变量的值为 1局部变量的值为 2局部变量的值为 3局部变量的值为 4局部变量的值为 5

Ruby break 语句

语法

break

终止最内部的循环。如果在块内调用，则终止相关块的方法（方法返回 nil）。

实例

#!/usr/bin/ruby# -*- coding: UTF-8 -*-for i in 0..5   if i > 2 then      break   end   puts "局部变量的值为 #{i}"end

以上实例输出结果为：

局部变量的值为 0局部变量的值为 1局部变量的值为 2

Ruby next 语句

语法

next

跳到最内部循环的下一个迭代。如果在块内调用，则终止块的执行（yield 或调用返回 nil）。

实例

#!/usr/bin/ruby# -*- coding: UTF-8 -*-for i in 0..5   if i < 2 then      next   end   puts "局部变量的值为 #{i}"end

以上实例输出结果为：

局部变量的值为 2局部变量的值为 3局部变量的值为 4局部变量的值为 5

Ruby redo 语句

语法

redo

重新开始最内部循环的该次迭代，不检查循环条件。如果在块内调用，则重新开始 yield 或 call。

实例

#!/usr/bin/ruby# -*- coding: UTF-8 -*-for i in 0..5   if i < 2 then      puts "局部变量的值为 #{i}"      redo   endend

这将产生以下结果，并会进入一个无限循环：

局部变量的值为 0局部变量的值为 0............................

Ruby retry 语句

语法

retry

如果 retry 出现在 begin 表达式的 rescue 子句中，则从 begin 主体的开头重新开始。

begin   do_something # 抛出的异常rescue   # 处理错误   retry  # 重新从 begin 开始end

如果 retry 出现在迭代内、块内或者 for 表达式的主体内，则重新开始迭代调用。迭代的参数会重新评估。

for i in 1..5   retry if some_condition # 重新从 i == 1 开始end

实例

#!/usr/bin/ruby# -*- coding: UTF-8 -*-for i in 1..5   retry if  i > 2   puts "局部变量的值为 #{i}"end

这将产生以下结果，并会进入一个无限循环：

局部变量的值为 1局部变量的值为 2局部变量的值为 1局部变量的值为 2局部变量的值为 1局部变量的值为 2............................

Ruby 方法

语法

def method_name [( [arg [= default]]...[, * arg [, &expr ]])]   expr..end

所以，您可以定义一个简单的方法，如下所示：

def method_name    expr..end

您可以定义一个接受参数的方法，如下所示：

def method_name (var1, var2)   expr..end

您可以为参数设置默认值，如果方法调用时未传递必需的参数则使用默认值：

def method_name (var1=value1, var2=value2)   expr..end

当您要调用方法时，只需要使用方法名即可，如下所示：

method_name

但是，当您调用带参数的方法时，您在写方法名时还要带上参数，例如：

method_name 25, 30

使用带参数方法最大的缺点是调用方法时需要记住参数个数。例如，如果您向一个接受三个参数的方法只传递了两个参数，Ruby 会显示错误。

实例

#!/usr/bin/ruby# -*- coding: UTF-8 -*-def test(a1="Ruby", a2="Perl")   puts "编程语言为 #{a1}"   puts "编程语言为 #{a2}"endtest "C", "C++"test

这将产生以下结果：

编程语言为 C编程语言为 C++编程语言为 Ruby编程语言为 Perl

从方法返回值

Ruby 中的每个方法默认都会返回一个值。这个返回的值是最后一个语句的值。例如：

def test   i = 100   j = 10   k = 0end

在调用这个方法时，将返回最后一个声明的变量 k。

Ruby return 语句

Ruby 中的 return 语句用于从 Ruby 方法中返回一个或多个值。

语法

return [expr[`,' expr...]]

如果给出超过两个的表达式，包含这些值的数组将是返回值。如果未给出表达式，nil 将是返回值。

实例

return或return 12或return 1,2,3

看看下面的实例：

#!/usr/bin/rubydef test   i = 100   j = 200   k = 300return i, j, kendvar = testputs var

这将产生以下结果：

100200300

可变数量的参数

假设您声明了一个带有两个参数的方法，当您调用该方法时，您同时还需要传递两个参数。

但是，Ruby 允许您声明参数数量可变的方法。让我们看看下面的实例：

#!/usr/bin/rubydef sample (*test)   puts "The number of parameters is #{test.length}"   for i in 0...test.length      puts "The parameters are #{test[i]}"   endendsample "Zara", "6", "F"sample "Mac", "36", "M", "MCA"

在这段代码中，您已经声明了一个方法 sample，接受一个参数 test。但是，这个参数是一个变量参数。这意味着参数可以带有不同数量的变量。所以上面的代码将产生下面的结果：

The number of parameters is 3The parameters are ZaraThe parameters are 6The parameters are FThe number of parameters is 4The parameters are MacThe parameters are 36The parameters are MThe parameters are MCA

类方法

当方法定义在类定义外部时，方法默认标记为 private。另一方面，定义在类定义中的方法默认标记为 public。方法默认的可见性和 private 标记可通过模块（Module）的 public 或 private 改变。

当你想要访问类的方法时，您首先需要实例化类。然后，使用对象，您可以访问类的任何成员。

Ruby 提供了一种不用实例化类即可访问方法的方式。让我们看看如何声明并访问类方法：

class Accounts   def reading_charge   end   def Accounts.return_date   endend

我们已经知道方法 return_date 是如何声明的。它是通过在类名后跟着一个点号，点号后跟着方法名来声明的。您可以直接访问类方法，如下所示：

Accounts.return_date

如需访问该方法，您不需要创建类 Accounts 的对象。

Ruby alias 语句

这个语句用于为方法或全局变量起别名。别名不能在方法主体内定义。即使方法被重写，方法的别名也保持方法的当前定义。

为编号的全局变量（$1, $2,...）起别名是被禁止的。重写内置的全局变量可能会导致严重的问题。

语法

alias 方法名 方法名alias 全局变量 全局变量

实例

alias foo baralias $MATCH $&

在这里，我们已经为 bar 定义了别名为 foo，为 $& 定义了别名为 $MATCH。

Ruby undef 语句

这个语句用于取消方法定义。undef 不能出现在方法主体内。

通过使用 undef 和 alias，类的接口可以从父类独立修改，但请注意，在自身内部方法调用时，它可能会破坏程序。

语法

undef 方法名

实例

下面的实例取消名为 bar的方法定义：

undef bar

Ruby 块

语法

block_name{   statement1   statement2   ..........}

在这里，您将学到如何使用一个简单的 yield 语句来调用块。您也将学到如何使用带有参数的 yield 语句来调用块。在实例中，您将看到这两种类型的 yield 语句。

yield 语句

让我们看一个 yield 语句的实例：

#!/usr/bin/ruby# -*- coding: UTF-8 -*-def test   puts "在 test 方法内"   yield   puts "你又回到了 test 方法内"   yieldendtest {puts "你在块内"}

这将产生以下结果：

在 test 方法内你在块内你又回到了 test 方法内你在块内

您也可以传递带有参数的 yield 语句。下面是一个实例：

#!/usr/bin/ruby# -*- coding: UTF-8 -*-def test   yield 5   puts "在 test 方法内"   yield 100endtest {|i| puts "你在块 #{i} 内"}

这将产生以下结果：

你在块 5 内在 test 方法内你在块 100 内

在这里，yield 语句后跟着参数。您甚至可以传递多个参数。在块中，您可以在两个竖线之间放置一个变量来接受参数。因此，在上面的代码中，yield 5 语句向 test 块传递值 5 作为参数。

现在，看下面的语句：

test {|i| puts "你在块 #{i} 内"}

在这里，值 5 会在变量 i 中收到。现在，观察下面的 puts 语句：

puts "你在块 #{i} 内"

这个 puts 语句的输出是：

你在块 5 内

如果您想要传递多个参数，那么 yield 语句如下所示：

yield a, b

此时，块如下所示：

test {|a, b| statement}

参数使用逗号分隔。

块和方法

您已经看到块和方法之间是如何相互关联的。您通常使用 yield 语句从与其具有相同名称的方法调用块。因此，代码如下所示：

#!/usr/bin/rubydef test  yieldendtest{ puts "Hello world"}

本实例是实现块的最简单的方式。您使用 yield 语句调用 test 块。

但是如果方法的最后一个参数前带有 &，那么您可以向该方法传递一个块，且这个块可被赋给最后一个参数。如果 * 和 & 同时出现在参数列表中，& 应放在后面。

#!/usr/bin/rubydef test(&block)   block.callendtest { puts "Hello World!"}

这将产生以下结果：

Hello World!

BEGIN 和 END 块

每个 Ruby 源文件可以声明当文件被加载时要运行的代码块（BEGIN 块），以及程序完成执行后要运行的代码块（END 块）。

#!/usr/bin/rubyBEGIN {   # BEGIN 代码块  puts "BEGIN 代码块"} END {   # END 代码块  puts "END 代码块"}  # MAIN 代码块puts "MAIN 代码块"

一个程序可以包含多个 BEGIN 和 END 块。BEGIN 块按照它们出现的顺序执行。END 块按照它们出现的相反顺序执行。当执行时，上面的程序产生产生以下结果：

BEGIN 代码块MAIN 代码块END 代码块

Ruby 模块（Module）

module Identifier   statement1   statement2   ...........end

模块常量命名与类常量命名类似，以大写字母开头。方法定义看起来也相似：模块方法定义与类方法定义类似。

通过类方法，您可以在类方法名称前面放置模块名称和一个点号来调用模块方法，您可以使用模块名称和两个冒号来引用一个常量。

实例

#!/usr/bin/ruby# 定义在 trig.rb 文件中的模块module Trig   PI = 3.141592654   def Trig.sin(x)   # ..   end   def Trig.cos(x)   # ..   endend

我们可以定义多个函数名称相同但是功能不同的模块：

#!/usr/bin/ruby# 定义在 moral.rb 文件中的模块module Moral   VERY_BAD = 0   BAD = 1   def Moral.sin(badness)   # ...   endend

就像类方法，当您在模块中定义一个方法时，您可以指定在模块名称后跟着一个点号，点号后跟着方法名。

Ruby require 语句

require 语句类似于 C 和 C++ 中的 include 语句以及 Java 中的 import 语句。如果一个第三方的程序想要使用任何已定义的模块，则可以简单地使用 Ruby require 语句来加载模块文件：

语法

require filename

在这里，文件扩展名 .rb 不是必需的。

实例

$LOAD_PATH << '.'require 'trig.rb'require 'moral'y = Trig.sin(Trig::PI/4)wrongdoing = Moral.sin(Moral::VERY_BAD)

在这里，我们使用 $LOAD_PATH << '.' 让 Ruby 知道必须在当前目录中搜索被引用的文件。如果您不想使用 $LOAD_PATH，那么您可以使用 require_relative 来从一个相对目录引用文件。

注意：在这里，文件包含相同的函数名称。所以，这会在引用调用程序时导致代码模糊，但是模块避免了这种代码模糊，而且我们可以使用模块的名称调用适当的函数。

Ruby include 语句

您可以在类中嵌入模块。为了在类中嵌入模块，您可以在类中使用 include 语句：

语法

include modulename

如果模块是定义在一个单独的文件中，那么在嵌入模块之前使用 require 语句引用该文件时必需的。

实例

假设下面的模块写在 support.rb 文件中。

module Week   FIRST_DAY = "Sunday"   def Week.weeks_in_month      puts "You have four weeks in a month"   end   def Week.weeks_in_year      puts "You have 52 weeks in a year"   endend

现在，您可以在类中引用该模块，如下所示：

#!/usr/bin/ruby$LOAD_PATH << '.'require "support"class Decadeinclude Week   no_of_yrs=10   def no_of_months      puts Week::FIRST_DAY      number=10*12      puts number   endendd1=Decade.newputs Week::FIRST_DAYWeek.weeks_in_monthWeek.weeks_in_yeard1.no_of_months

这将产生以下结果：

SundayYou have four weeks in a monthYou have 52 weeks in a yearSunday120

Ruby 中的 Mixins

在阅读本节之前，您需要初步了解面向对象的概念。

当一个类可以从多个父类继承类的特性时，该类显示为多重继承。

Ruby 不直接支持多重继承，但是 Ruby 的模块（Module）有另一个神奇的功能。它几乎消除了多重继承的需要，提供了一种名为 mixin 的装置。

Mixins 向您提供了一种完美的为类添加功能的控制方式。但是，它们真正的强大在于当 mixin 中的代码开始与使用它的类中的代码交互时。

让我们看看下面的示例代码，深入了解 mixin：

module A   def a1   end   def a2   endendmodule B   def b1   end   def b2   endendclass Sampleinclude Ainclude B   def s1   endendsamp=Sample.newsamp.a1samp.a2samp.b1samp.b2samp.s1

• 模块 A 由方法 a1 和 a2 组成。
• 模块 B 由方法 b1 和 b2 组成。
• 类 Sample 包含了模块 A 和 B。
• 类 Sample 可以访问所有四个方法，即 a1、a2、b1 和 b2。
    因此，您可以看到类 Sample 继承了两个模块，您可以说类 Sample 使用了多重继承或 mixin 。

Ruby 字符串（String）

'这是一个 Ruby 程序的字符串'

'Won't you read O'Reilly's book?'

#!/usr/bin/ruby# -*- coding: UTF-8 -*-name1 = "Joe"name2 = "Mary"puts "你好 #{name1},  #{name2} 在哪?"

以上实例输出运行输出结果为：

你好 Joe,  Mary 在哪?

字符串中进行数学运算：

#!/usr/bin/ruby# -*- coding: UTF-8 -*-x, y, z = 12, 36, 72puts "x 的值为 #{ x }"puts "x + y 的值为 #{ x + y }"puts "x + y + z 的平均值为 #{ (x + y + z)/3 }"

以上实例输出运行输出结果为：

x 的值为 12x + y 的值为 48x + y + z 的平均值为 40

Ruby 中还支持一种采用 %q 和 %Q 来引导的字符串变量，%q 使用的是单引号引用规则，而 %Q 是双引号引用规则，后面再接一个 (! [ { 等等的开始界定符和与 } ] ) 等等的末尾界定符。

跟在q或Q后面的字符是分界符.分界符可以是任意一个非字母数字的单字节字符.如:[,{,(,<,!等,字符串会一直读取到发现相匹配的结束符为止.

#!/usr/bin/ruby# -*- coding: UTF-8 -*-desc1 = %Q{Ruby 的字符串可以使用 '' 和 ""。}desc2 = %q|Ruby 的字符串可以使用 '' 和 ""。|puts desc1puts desc2

Ruby 的字符串可以使用 '' 和 ""。Ruby 的字符串可以使用 '' 和 ""。

转义字符

下标列出了可使用反斜杠符号转义的转义字符或非打印字符。

注意：在一个双引号括起的字符串内，转义字符会被解释；在一个单引号括起的字符串内，转义字符会被保留。

字符编码

Ruby 的默认字符集是 ASCII，字符可用单个字节表示。如果您使用 UTF-8 或其他现代的字符集，字符可能是用一个到四个字节表示。

您可以在程序开头使用 $KCODE 改变字符集，如下所示：

$KCODE = 'u'

下面是 $KCODE 可能的值。

字符串内建方法

我们需要有一个 String 对象的实例来调用 String 方法。下面是创建 String 对象实例的方式：

new [String.new(str="")]

这将返回一个包含 str 副本的新的字符串对象。现在，使用 str 对象，我们可以调用任意可用的实例方法。例如：

#!/usr/bin/rubymyStr = String.new("THIS IS TEST")foo = myStr.downcaseputs "#{foo}"

这将产生以下结果：

this is test

下面是公共的字符串方法（假设 str 是一个 String 对象）：

字符串 unpack 指令

下表列出了方法 String#unpack 的解压指令。

实例

尝试下面的实例，解压各种数据。

"abc abc ".unpack('A6Z6')           #=> ["abc", "abc "]"abc ".unpack('a3a3')               #=> ["abc", " 0000"]"abc abc ".unpack('Z*Z*')           #=> ["abc ", "abc "]"aa".unpack('b8B8')                 #=> ["10000110", "01100001"]"aaa".unpack('h2H2c')               #=> ["16", "61", 97]"xfexffxfexff".unpack('sS')     #=> [-2, 65534]"now=20is".unpack('M*')             #=> ["now is"]"whole".unpack('xax2aX2aX1aX2a')    #=> ["h", "e", "l", "l", "o"]

Ruby 数组（Array）

创建数组

有多种方式创建或初始化数组。一种方式是通过 new 类方法：

names = Array.new

您可以在创建数组的同时设置数组的大小：

names = Array.new(20)

数组 names 的大小或长度为 20 个元素。您可以使用 size 或 length 方法返回数组的大小：

#!/usr/bin/rubynames = Array.new(20)puts names.size  # 返回 20puts names.length # 返回 20

这将产生以下结果：

2020

您可以给数组中的每个元素赋值，如下所示：

#!/usr/bin/rubynames = Array.new(4, "mac")puts "#{names}"

这将产生以下结果：

macmacmacmac

您也可以使用带有 new 的块，每个元素使用块中的计算结果来填充：

#!/usr/bin/rubynums = Array.new(10) { |e| e = e * 2 }puts "#{nums}"

这将产生以下结果：

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

数组还有另一种方法，[]，如下所示：

nums = Array.[](1, 2, 3, 4,5)

数组创建的另一种形式如下所示：

nums = Array[1, 2, 3, 4,5]

在 Ruby 核心模块中可以有一个只接收单个参数的 Array 方法，该方法使用一个范围作为参数来创建一个数字数组：

#!/usr/bin/rubydigits = Array(0..9)puts "#{digits}"

以上实例运行输出结果为：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

数组内建方法

我们需要有一个 Array 对象的实例来调用 Array 方法。下面是创建 Array 对象实例的方式：

Array.[](...) [or] Array[...] [or] [...]

这将返回一个使用给定对象进行填充的新的数组。现在，使用创建的对象，我们可以调用任意可用的实例方法。例如：

#!/usr/bin/rubydigits = Array(0..9)num = digits.at(6)puts "#{num}"

这将产生以下结果：

6

下面是公共的数组方法（假设 array 是一个 Array 对象）：

数组 pack 指令

下表列出了方法 Array#pack 的压缩指令。

实例

尝试下面的实例，压缩各种数据。

a = [ "a", "b", "c" ]n = [ 65, 66, 67 ]puts a.pack("A3A3A3")   #=> "a  b  c  "puts a.pack("a3a3a3")   #=> "a0000b0000c0000"puts n.pack("ccc")      #=> "ABC"

这将产生以下结果：

a  b  cabcABC

Ruby 哈希（Hash）

创建哈希

与数组一样，有各种不同的方式来创建哈希。您可以通过 new 类方法创建一个空的哈希：

months = Hash.new

您也可以使用 new 创建带有默认值的哈希，不带默认值的哈希是 nil：

months = Hash.new( "month" )或months = Hash.new "month"

当您访问带有默认值的哈希中的任意键时，如果键或值不存在，访问哈希将返回默认值：

#!/usr/bin/rubymonths = Hash.new( "month" )puts "#{months[0]}"puts "#{months[72]}"

这将产生以下结果：

monthmonth

#!/usr/bin/rubyH = Hash["a" => 100, "b" => 200]puts "#{H['a']}"puts "#{H['b']}"

这将产生以下结果：

100200

您可以使用任何的 Ruby 对象作为键或值，甚至可以使用数组，所以下面的实例是一个有效的实例：

[1,"jan"] => "January"

哈希内置方法

我们需要有一个 Hash 对象的实例来调用 Hash 方法。下面是创建 Hash 对象实例的方式：

Hash[[key =>|, value]* ] orHash.new [or] Hash.new(obj) [or]Hash.new { |hash, key| block }

这将返回一个使用给定对象进行填充的新的哈希。现在，使用创建的对象，我们可以调用任意可用的实例方法。例如：

#!/usr/bin/ruby$, = ", "months = Hash.new( "month" )months = {"1" => "January", "2" => "February"}keys = months.keysputs "#{keys}"

这将产生以下结果：

2, 1

下面是公共的哈希方法（假设 hash 是一个 Hash 对象）：

Ruby 日期 & 时间（Date & Time）

创建当前的日期和时间

下面是获取当前的日期和时间的简单实例：

这将产生以下结果：

Current Time : Mon Jun 02 12:02:39 -0700 2008Current Time : Mon Jun 02 12:02:39 -0700 2008

获取 Date & Time 组件

我们可以使用 Time 对象来获取各种日期和时间的组件。请看下面的实例：

#!/usr/bin/ruby -w# -*- coding: UTF-8 -*-time = Time.new# Time 的组件puts "当前时间 : " + time.inspectputs time.year    # => 日期的年份puts time.month   # => 日期的月份（1 到 12）puts time.day     # => 一个月中的第几天（1 到 31）puts time.wday    # => 一周中的星期几（0 是星期日）puts time.yday    # => 365：一年中的第几天puts time.hour    # => 23：24 小时制puts time.min     # => 59puts time.sec     # => 59puts time.usec    # => 999999：微秒puts time.zone    # => "UTC"：时区名称

这将产生以下结果：

当前时间 : 2015-09-17 15:24:44 +080020159174260152444921519CST

Time.utc、Time.gm 和 Time.local 函数

这些函数可用于格式化标准格式的日期，如下所示：

# July 8, 2008Time.local(2008, 7, 8)  # July 8, 2008, 09:10am，本地时间Time.local(2008, 7, 8, 9, 10)   # July 8, 2008, 09:10 UTCTime.utc(2008, 7, 8, 9, 10)  # July 8, 2008, 09:10:11 GMT （与 UTC 相同）Time.gm(2008, 7, 8, 9, 10, 11)  

下面的实例在数组中获取所有的组件：

[sec,min,hour,day,month,year,wday,yday,isdst,zone]

尝试下面的实例：

#!/usr/bin/ruby -wtime = Time.newvalues = time.to_ap values

以上实例运行输出结果为：

[39, 25, 15, 17, 9, 2015, 4, 260, false, "CST"]

该数组可被传到 Time.utc 或 Time.local 函数来获取日期的不同格式，如下所示：

#!/usr/bin/ruby -wtime = Time.newvalues = time.to_aputs Time.utc(*values)

以上实例运行输出结果为：

2015-09-17 15:26:09 UTC

下面是获取时间的方式，从纪元以来的秒数（平台相关）：

# 返回从纪元以来的秒数time = Time.now.to_i  # 把秒数转换为 Time 对象Time.at(time)# 返回从纪元以来的秒数，包含微妙time = Time.now.to_f

时区和夏令时

您可以使用 Time 对象来获取与时区和夏令时有关的所有信息，如下所示：

time = Time.new# 这里是解释time.zone       # => "UTC"：返回时区time.utc_offset # => 0：UTC 是相对于 UTC 的 0 秒偏移time.zone       # => "PST"（或其他时区）time.isdst      # => false：如果 UTC 没有 DST（夏令时）time.utc?       # => true：如果在 UTC 时区time.localtime  # 转换为本地时区time.gmtime     # 转换回 UTCtime.getlocal   # 返回本地区中的一个新的 Time 对象time.getutc     # 返回 UTC 中的一个新的 Time 对象

格式化时间和日期

有多种方式格式化日期和时间。下面的实例演示了其中一部分：

#!/usr/bin/ruby -wtime = Time.newputs time.to_sputs time.ctimeputs time.localtimeputs time.strftime("%Y-%m-%d %H:%M:%S")

以上实例运行输出结果为：

2015-09-17 15:26:42 +0800Thu Sep 17 15:26:42 20152015-09-17 15:26:42 +08002015-09-17 15:26:42

时间格式化指令

下表所列出的指令与方法 Time.strftime 一起使用。

时间算法

您可以用时间做一些简单的算术，如下所示：

now = Time.now           # 当前时间puts nowpast = now - 10          # 10 秒之前。Time - number => Timeputs pastfuture = now + 10        # 从现在开始 10 秒之后。Time + number => Timeputs futurediff = future - now      # => 10  Time - Time => 秒数puts diff

这将产生以下结果：

Thu Aug 01 20:57:05 -0700 2013Thu Aug 01 20:56:55 -0700 2013Thu Aug 01 20:57:15 -0700 201310.0

Ruby 范围（Range）

作为序列的范围

范围的第一个也是最常见的用途是表达序列。序列有一个起点、一个终点和一个在序列产生连续值的方式。

Ruby 使用 ''..'' 和 ''...'' 范围运算符创建这些序列。两点形式创建一个包含指定的最高值的范围，三点形式创建一个不包含指定的最高值的范围。

(1..5)        #==> 1, 2, 3, 4, 5(1...5)       #==> 1, 2, 3, 4('a'..'d')    #==> 'a', 'b', 'c', 'd'

序列 1..100 是一个 Range 对象，包含了两个 Fixnum 对象的引用。如果需要，您可以使用 to_a 方法把范围转换为列表。尝试下面的实例：

#!/usr/bin/ruby$, =", "   # Array 值分隔符range1 = (1..10).to_arange2 = ('bar'..'bat').to_aputs "#{range1}"puts "#{range2}"

这将产生以下结果：

1, 2, 3, 4, 5, 6, 7, 8, 9, 10bar, bas, bat

范围实现了让您可以遍历它们的方法，您可以通过多种方式检查它们的内容：

#!/usr/bin/ruby# -*- coding: UTF-8 -*-# 指定范围digits = 0..9puts digits.include?(5)ret = digits.minputs "最小值为 #{ret}"ret = digits.maxputs "最大值为 #{ret}"ret = digits.reject {|i| i < 5 }puts "不符合条件的有 #{ret}"digits.each do |digit|   puts "在循环中 #{digit}"end

这将产生以下结果：

true最小值为 0最大值为 9不符合条件的有 [5, 6, 7, 8, 9]在循环中 0在循环中 1在循环中 2在循环中 3在循环中 4在循环中 5在循环中 6在循环中 7在循环中 8在循环中 9

作为条件的范围

范围也可以用作条件表达式。例如，下面的代码片段从标准输入打印行，其中每个集合的第一行包含单词 start，最后一行包含单词 end.：

while gets   print if /start/../end/end

范围可以用在 case 语句中：

#!/usr/bin/ruby# -*- coding: UTF-8 -*-score = 70result = case scorewhen 0..40	"糟糕的分数"when 41..60	"快要及格"when 61..70	"及格分数"when 71..100   	"良好分数"else	"错误的分数"endputs result

这将产生以下结果：

及格分数

作为间隔的范围

范围的最后一个用途是间隔测试：检查某些值是否落在范围表示的间隔里。这是使用 === 相等运算符来完成计算

#!/usr/bin/rubyif ((1..10) === 5)  puts "5 lies in (1..10)"endif (('a'..'j') === 'c')  puts "c lies in ('a'..'j')"endif (('a'..'j') === 'z')  puts "z lies in ('a'..'j')"end

这将产生以下结果：

5 lies in (1..10)c lies in ('a'..'j')

Ruby 迭代器

Ruby each 迭代器

each 迭代器返回数组或哈希的所有元素。

语法

collection.each do |variable|   codeend

为集合中的每个元素执行 code。在这里，集合可以是数组或哈希。

实例

#!/usr/bin/rubyary = [1,2,3,4,5]ary.each do |i|   puts iend

这将产生以下结果：

12345

each 迭代器总是与一个块关联。它向块返回数组的每个值，一个接着一个。值被存储在变量 i 中，然后显示在屏幕上。

Ruby collect 迭代器

collect 迭代器返回集合的所有元素。

语法

collection = collection.collect

collect 方法不需要总是与一个块关联。collect 方法返回整个集合，不管它是数组或者是哈希。

实例

#!/usr/bin/rubya = [1,2,3,4,5]b = Array.newb = a.collect{ |x|x }puts b

这将产生以下结果：

12345

注意：collect 方法不是数组间进行复制的正确方式。这里有另一个称为 clone 的方法，用于复制一个数组到另一个数组。

当您想要对每个值进行一些操作以便获得新的数组时，您通常使用 collect 方法。例如，下面的代码会生成一个数组，其值是 a 中每个值的 10 倍。

#!/usr/bin/rubya = [1,2,3,4,5]b = a.collect{|x| 10*x}puts b

这将产生以下结果：

1020304050

Ruby 文件的输入与输出

puts 语句

在前面的章节中，您赋值给变量，然后使用 puts 语句打印输出。

puts 语句指示程序显示存储在变量中的值。这将在每行末尾添加一个新行。

实例

#!/usr/bin/rubyval1 = "This is variable one"val2 = "This is variable two"puts val1puts val2

这将产生以下结果：

This is variable oneThis is variable two

gets 语句

gets 语句可用于获取来自名为 STDIN 的标准屏幕的用户输入。

实例

下面的代码演示了如何使用 gets 语句。该代码将提示用户输入一个值，该值将被存储在变量 val 中，最后会被打印在 STDOUT 上。

#!/usr/bin/rubyputs "Enter a value :"val = getsputs val

这将产生以下结果：

Enter a value :This is entered valueThis is entered value

putc 语句

与 puts 语句不同，puts 语句输出整个字符串到屏幕上，而 putc 语句可用于依次输出一个字符。

实例

下面代码的输出只是字符 H：

#!/usr/bin/rubystr="Hello Ruby!"putc str

这将产生以下结果：

H

print 语句

print 语句与 puts 语句类似。唯一的不同在于 puts 语句在输出内容后会跳到下一行，而使用 print 语句时，光标定位在同一行。

实例

#!/usr/bin/rubyprint "Hello World"print "Good Morning"

这将产生以下结果：

Hello WorldGood Morning

打开和关闭文件

截至现在，您已经读取并写入标准输入和输出。现在，我们将看看如何操作实际的数据文件。

File.new 方法

您可以使用 File.new 方法创建一个 File 对象用于读取、写入或者读写，读写权限取决于 mode 字符串。最后，您可以使用 File.close 方法来关闭该文件。

语法

aFile = File.new("filename", "mode")   # ... 处理文件aFile.close

File.open 方法

您可以使用 File.open 方法创建一个新的 file 对象，并把该 file 对象赋值给文件。但是，File.open 和 File.new 方法之间有一点不同。不同点是 File.open 方法可与块关联，而 File.new 方法不能。

File.open("filename", "mode") do |aFile|   # ... process the fileend

下表列出了打开文件的不同模式：

读取和写入文件

用于简单 I/O 的方法也可用于所有 file 对象。所以，gets 从标准输入读取一行，aFile.gets 从文件对象 aFile 读取一行。

但是，I/O 对象提供了访问方法的附加设置，为我们提供了便利。

sysread 方法

您可以使用方法 sysread 来读取文件的内容。当使用方法 sysread 时，您可以使用任意一种模式打开文件。例如：

下面是输入文本文件：

This is a simple text file for testing purpose.

现在让我们尝试读取这个文件：

#!/usr/bin/rubyaFile = File.new("input.txt", "r")if aFile   content = aFile.sysread(20)   puts contentelse   puts "Unable to open file!"end

该语句将输入文件的头 20 个字符。文件指针将被放置在文件中第 21 个字符的位置。

syswrite 方法

您可以使用方法 syswrite 来向文件写入内容。当使用方法 syswrite 时，您需要以写入模式打开文件。例如：

#!/usr/bin/rubyaFile = File.new("input.txt", "r+")if aFile   aFile.syswrite("ABCDEF")else   puts "Unable to open file!"end

该语句将写入 "ABCDEF" 到文件中。

each_byte 方法

该方法属于类 File。方法 each_byte 是个可以迭代字符串中每个字符。请看下面的代码实例：

#!/usr/bin/rubyaFile = File.new("input.txt", "r+")if aFile   aFile.syswrite("ABCDEF")   aFile.rewind   aFile.each_byte {|ch| putc ch; putc ?. }else   puts "Unable to open file!"end

字符一个接着一个被传到变量 ch，然后显示在屏幕上，如下所示：

A.B.C.D.E.F.s. .a. .s.i.m.p.l.e. .t.e.x.t. .f.i.l.e. .f.o.r. .t.e.s.t.i.n.g. .p.u.r.p.o.s.e...

IO.readlines 方法

类 File 是类 IO 的一个子类。类 IO 也有一些用于操作文件的方法。

IO.readlines 是 IO 类中的一个方法。该方法逐行返回文件的内容。下面的代码显示了方法 IO.readlines 的使用：

#!/usr/bin/rubyarr = IO.readlines("input.txt")puts arr[0]puts arr[1]

在这段代码中，变量 arr 是一个数组。文件 input.txt 的每一行将是数组 arr 中的一个元素。因此，arr[0] 将包含第一行，而 arr[1] 将包含文件的第二行。

IO.foreach 方法

该方法也逐行返回输出。方法 foreach 与方法 readlines 之间不同的是，方法 foreach 与块相关联。但是，不像方法 readlines，方法 foreach 不是返回一个数组。例如：

#!/usr/bin/rubyIO.foreach("input.txt"){|block| puts block}

这段代码将把文件 test 的内容逐行传给变量 block，然后输出将显示在屏幕上。

重命名和删除文件

您可以通过 rename 和 delete 方法重命名和删除文件。

下面的实例重命名一个已存在文件 test1.txt：

#!/usr/bin/ruby# 重命名文件 test1.txt 为 test2.txtFile.rename( "test1.txt", "test2.txt" )

下面的实例删除一个已存在文件 test2.txt：

#!/usr/bin/ruby# 删除文件 test2.txtFile.delete("text2.txt")

文件模式与所有权

使用带有掩码的 chmod 方法来改变文件的模式或权限/访问列表：

下面的实例改变一个已存在文件 test.txt 的模式为一个掩码值：

#!/usr/bin/rubyfile = File.new( "test.txt", "w" )file.chmod( 0755 )

下表列出了 chmod 方法中可使用的不同的掩码：

文件查询

下面的命令在打开文件前检查文件是否已存在：

#!/usr/bin/rubyFile.open("file.rb") if File::exists?( "file.rb" )

下面的命令查询文件是否确实是一个文件：

#!/usr/bin/ruby# 返回 true 或falseFile.file?( "text.txt" ) 

下面的命令检查给定的文件名是否是一个目录：

#!/usr/bin/ruby# 一个目录File::directory?( "/usr/local/bin" ) # => true# 一个文件File::directory?( "file.rb" ) # => false

下面的命令检查文件是否可读、可写、可执行：

#!/usr/bin/rubyFile.readable?( "test.txt" )   # => trueFile.writable?( "test.txt" )   # => trueFile.executable?( "test.txt" ) # => false

下面的命令检查文件是否大小为零：

#!/usr/bin/rubyFile.zero?( "test.txt" )      # => true

下面的命令返回文件的大小：

#!/usr/bin/rubyFile.size?( "text.txt" )     # => 1002

下面的命令用于检查文件的类型：

#!/usr/bin/rubyFile::ftype( "test.txt" )     # => file

ftype 方法通过返回下列中的某个值来标识了文件的类型：file、 directory、 characterSpecial、 blockSpecial、 fifo、 link、 socket 或 unknown。

下面的命令用于检查文件被创建、修改或最后访问的时间：

#!/usr/bin/rubyFile::ctime( "test.txt" ) # => Fri May 09 10:06:37 -0700 2008File::mtime( "text.txt" ) # => Fri May 09 10:44:44 -0700 2008File::atime( "text.txt" ) # => Fri May 09 10:45:01 -0700 2008

Ruby 中的目录

所有的文件都是包含在目录中，Ruby 提供了处理文件和目录的方式。File 类用于处理文件，Dir 类用于处理目录。

浏览目录

为了在 Ruby 程序中改变目录，请使用 Dir.chdir。下面的实例改变当前目录为 /usr/bin。

Dir.chdir("/usr/bin")

您可以通过 Dir.pwd 查看当前目录：

puts Dir.pwd # 返回当前目录，类似 /usr/bin

您可以使用 Dir.entries 获取指定目录内的文件和目录列表：

puts Dir.entries("/usr/bin").join(' ')

Dir.entries 返回一个数组，包含指定目录内的所有项。Dir.foreach 提供了相同的功能：

Dir.foreach("/usr/bin") do |entry|   puts entryend

获取目录列表的一个更简洁的方式是通过使用 Dir 的类数组的方法：

Dir["/usr/bin/*"]

创建目录

Dir.mkdir 可用于创建目录：

Dir.mkdir("mynewdir")

您也可以通过 mkdir 在新目录（不是已存在的目录）上设置权限：

注意：掩码 755 设置所有者（owner）、所属组（group）、每个人（world [anyone]）的权限为 rwxr-xr-x，其中 r = read 读取，w = write 写入，x = execute 执行。

Dir.mkdir( "mynewdir", 755 )

删除目录

Dir.delete 可用于删除目录。Dir.unlink 和 Dir.rmdir 执行同样的功能，为我们提供了便利。

Dir.delete("testdir")

创建文件 & 临时目录

临时文件是那些在程序执行过程中被简单地创建，但不会永久性存储的信息。

Dir.tmpdir 提供了当前系统上临时目录的路径，但是该方法默认情况下是不可用的。为了让 Dir.tmpdir 可用，使用必需的 'tmpdir' 是必要的。

您可以把 Dir.tmpdir 和 File.join 一起使用，来创建一个独立于平台的临时文件：

require 'tmpdir'   tempfilename = File.join(Dir.tmpdir, "tingtong")   tempfile = File.new(tempfilename, "w")   tempfile.puts "This is a temporary file"   tempfile.close   File.delete(tempfilename)

这段代码创建了一个临时文件，并向其中写入数据，然后删除文件。Ruby 的标准库也包含了一个名为 Tempfile 的库，该库可用于创建临时文件：

require 'tempfile'   f = Tempfile.new('tingtong')   f.puts "Hello"   puts f.path   f.close

内建函数

下面提供了 Ruby 中处理文件和目录的内建函数的完整列表：

• File 类和方法。

• Dir 类和方法。

Ruby File 类和方法

类方法

实例方法

假设 f 是 File 类的一个实例：

Ruby Dir 类和方法

类方法

实例方法

假设 d 是 Dir 类的一个实例：

Ruby 异常

语法

begin #开始  raise.. #抛出异常 rescue [ExceptionType = StandardException] #捕获指定类型的异常 缺省值是StandardException $! #表示异常信息 $@ #表示异常出现的代码位置else #其余异常 ..ensure #不管有没有异常，进入该代码块 end #结束

从 begin 到 rescue 中的一切是受保护的。如果代码块执行期间发生了异常，控制会传到 rescue 和 end 之间的块。

对于 begin 块中的每个 rescue 子句，Ruby 把抛出的异常与每个参数进行轮流比较。如果 rescue 子句中命名的异常与当前抛出的异常类型相同，或者是该异常的父类，则匹配成功。

如果异常不匹配所有指定的错误类型，我们可以在所有的 rescue 子句后使用一个 else 子句。

实例

#!/usr/bin/rubybegin   file = open("/unexistant_file")   if file      puts "File opened successfully"   endrescue      file = STDINendprint file, "==", STDIN, "
"

这将产生以下结果。您可以看到，STDIN 取代了 file ，因为打开失败。

#<IO:0xb7d16f84>==#<IO:0xb7d16f84>

使用 retry 语句

您可以使用 rescue 块捕获异常，然后使用 retry 语句从开头开始执行 begin 块。

语法

begin    # 这段代码抛出的异常将被下面的 rescue 子句捕获rescue    # 这个块将捕获所有类型的异常    retry  # 这将把控制移到 begin 的开头end

实例

#!/usr/bin/rubybegin   file = open("/unexistant_file")   if file      puts "File opened successfully"   endrescue   fname = "existant_file"   retryend

以下是处理流程：

• 打开时发生异常。
• 跳到 rescue。fname 被重新赋值。
• 通过 retry 跳到 begin 的开头。
• 这次文件成功打开。
• 继续基本的过程。

注意：如果被重新命名的文件不存在，本势力代码会无限尝试。所以异常处理时，谨慎使用 retry。

使用 raise 语句

您可以使用 raise 语句抛出异常。下面的方法在调用时抛出异常。它的第二个消息将被输出。

语法

raise ORraise "Error Message" ORraise ExceptionType, "Error Message"ORraise ExceptionType, "Error Message" condition

第一种形式简单地重新抛出当前异常（如果没有当前异常则抛出一个 RuntimeError）。这用在传入异常之前需要解释异常的异常处理程序中。

第二种形式创建一个新的 RuntimeError 异常，设置它的消息为给定的字符串。该异常之后抛出到调用堆栈。

第三种形式使用第一个参数创建一个异常，然后设置相关的消息为第二个参数。

第四种形式与第三种形式类似，您可以添加任何额外的条件语句（比如 unless）来抛出异常。

实例

#!/usr/bin/rubybegin      puts 'I am before the raise.'      raise 'An error has occurred.'      puts 'I am after the raise.'  rescue      puts 'I am rescued.'  end  puts 'I am after the begin block.'  

这将产生以下结果：

I am before the raise.  I am rescued.  I am after the begin block.  

另一个演示 raise 用法的实例：

#!/usr/bin/rubybegin    raise 'A test exception.'  rescue Exception => e    puts e.message    puts e.backtrace.inspect  end  

这将产生以下结果：

A test exception.["main.rb:4"]

使用 ensure 语句

有时候，无论是否抛出异常，您需要保证一些处理在代码块结束时完成。例如，您可能在进入时打开了一个文件，当您退出块时，您需要确保关闭文件。

ensure 子句做的就是这个。ensure 放在最后一个 rescue 子句后，并包含一个块终止时总是执行的代码块。它与块是否正常退出、是否抛出并处理异常、是否因一个未捕获的异常而终止，这些都没关系，ensure 块始终都会运行。

语法

begin    #.. 过程   #.. 抛出异常rescue    #.. 处理错误 ensure    #.. 最后确保执行   #.. 这总是会执行end

实例

begin  raise 'A test exception.'rescue Exception => e  puts e.message  puts e.backtrace.inspectensure  puts "Ensuring execution"end

这将产生以下结果：

A test exception.["main.rb:4"]Ensuring execution

使用 else 语句

如果提供了 else 子句，它一般是放置在 rescue 子句之后，任意 ensure 之前。

else 子句的主体只有在代码主体没有抛出异常时执行。

语法

begin    #.. 过程    #.. 抛出异常rescue    #.. 处理错误else   #.. 如果没有异常则执行ensure    #.. 最后确保执行   #.. 这总是会执行end

实例

begin # 抛出 'A test exception.' puts "I'm not raising exception"rescue Exception => e  puts e.message  puts e.backtrace.inspectelse   puts "Congratulations-- no errors!"ensure  puts "Ensuring execution"end

这将产生以下结果：

I'm not raising exceptionCongratulations-- no errors!Ensuring execution

使用 $! 变量可以捕获抛出的错误消息。

Catch 和 Throw

raise 和 rescue 的异常机制能在发生错误时放弃执行，有时候需要在正常处理时跳出一些深层嵌套的结构。此时 catch 和 throw 就派上用场了。

catch 定义了一个使用给定的名称（可以是 Symbol 或 String）作为标签的块。块会正常执行知道遇到一个 throw。

语法

throw :lablename#.. 这不会被执行catch :lablename do#.. 在遇到一个 throw 后匹配将被执行的 catchendORthrow :lablename condition#.. 这不会被执行catch :lablename do#.. 在遇到一个 throw 后匹配将被执行的 catchend

实例

下面的实例中，如果用户键入 '!' 回应任何提示，使用一个 throw 终止与用户的交互。

def promptAndGet(prompt)   print prompt   res = readline.chomp   throw :quitRequested if res == "!"   return resendcatch :quitRequested do   name = promptAndGet("Name: ")   age = promptAndGet("Age: ")   sex = promptAndGet("Sex: ")   # ..   # 处理信息endpromptAndGet("Name:")

上面的程序需要人工交互，您可以在您的计算机上进行尝试。这将产生以下结果：

Name: Ruby on RailsAge: 3Sex: !Name:Just Ruby

类 Exception

Ruby 的标准类和模块抛出异常。所有的异常类组成一个层次，包括顶部的 Exception 类在内。下一层是七种不同的类型：

• Interrupt
• NoMemoryError
• SignalException
• ScriptError
• StandardError
• SystemExit

Fatal 是该层中另一种异常，但是 Ruby 解释器只在内部使用它。

ScriptError 和 StandardError 都有一些子类，但是在这里我们不需要了解这些细节。最重要的事情是创建我们自己的异常类，它们必须是类 Exception 或其子代的子类。

让我们看一个实例：

class FileSaveError < StandardError   attr_reader :reason   def initialize(reason)      @reason = reason   endend

现在，看下面的实例，将用到上面的异常：

File.open(path, "w") do |file|begin    # 写出数据 ...rescue    # 发生错误    raise FileSaveError.new($!)endend

在这里，最重要的一行是 raise FileSaveError.new($!)。我们调用 raise 来示意异常已经发生，把它传给 FileSaveError 的一个新的实例，由于特定的异常引起数据写入失败。

Ruby 面向对象

Ruby 类定义

当您定义一个类时，您实际是定义了一个数据类型的蓝图。这实际上并没有定义任何的数据，而是定义了类的名称意味着什么，也就是说，定义了类的对象将由什么组成，以及在该对象上能执行什么操作。

类定义以关键字 class 开始，后跟类名称，最后以一个 end 进行分隔表示终止该类定义。例如，我们使用关键字 class 来定义 Box 类，如下所示：

class Box   codeend

按照惯例，名称必须以大写字母开头，如果包含多个单词，每个单词首字母大写，但此间没有分隔符（例如：CamelCase）。

定义 Ruby 对象

类提供了对象的蓝图，所以基本上，对象是根据类进行创建的。我们使用 new 关键字声明类的对象。下面的语句声明了类 Box 的两个对象：

box1 = Box.newbox2 = Box.new

initialize 方法

initialize 方法是一个标准的 Ruby 类方法，与其他面向对象编程语言中的 constructor 工作原理类似。当您想要在创建对象的同时初始化一些类变量，initialize 方法就派上用场了。该方法带有一系列参数，与其他 Ruby 方法一样，使用该方法时，必须在前面放置 def 关键字，如下所示：

class Box   def initialize(w,h)      @width, @height = w, h   endend

实例变量

实例变量是类属性，它们在使用类创建对象时就变成对象的属性。每个对象的属性是单独赋值的，和其他对象之间不共享值。在类的内部，是使用 @ 运算符访问这些属性，在类的外部，则是使用称为访问器方法的公共方法进行访问。下面我们以上面定义的类 Box 为实例，把 @width 和 @height 作为类 Box 的实例变量。

class Box   def initialize(w,h)      # 给实例变量赋值      @width, @height = w, h   endend

访问器 & 设置器 方法

为了在类的外部使用变量，我们必须在访问器方法内部定义这些变量，这些访问器方法也被称为获取器方法。下面的实例演示了访问器方法的用法：

#!/usr/bin/ruby -w# 定义类class Box   # 构造器方法   def initialize(w,h)      @width, @height = w, h   end   # 访问器方法   def printWidth      @width   end   def printHeight      @height   endend# 创建对象box = Box.new(10, 20)# 使用访问器方法x = box.printWidth()y = box.printHeight()puts "Width of the box is : #{x}"puts "Height of the box is : #{y}"

当上面的代码执行时，它会产生以下结果：

Width of the box is : 10Height of the box is : 20

与用于访问变量值的访问器方法类似，Ruby 提供了一种在类的外部设置变量值的方式，也就是所谓的设置器方法，定义如下：

#!/usr/bin/ruby -w# 定义类class Box   # 构造器方法   def initialize(w,h)      @width, @height = w, h   end   # 访问器方法   def getWidth      @width   end   def getHeight      @height   end   # 设置器方法   def setWidth=(value)      @width = value   end   def setHeight=(value)      @height = value   endend# 创建对象box = Box.new(10, 20)# 使用设置器方法box.setWidth = 30box.setHeight = 50# 使用访问器方法x = box.getWidth()y = box.getHeight()puts "Width of the box is : #{x}"puts "Height of the box is : #{y}"

当上面的代码执行时，它会产生以下结果：

Width of the box is : 30Height of the box is : 50

实例方法

实例方法的定义与其他方法的定义一样，都是使用 def 关键字，但它们只能通过类实例来使用，如下面实例所示。它们的功能不限于访问实例变量，也能按照您的需求做更多其他的任务。

#!/usr/bin/ruby -w# 定义类class Box   # constructor method   def initialize(w,h)      @width, @height = w, h   end   # 实例方法   def getArea      @width * @height   endend# 创建对象box = Box.new(10, 20)# 调用实例方法a = box.getArea()puts "Area of the box is : #{a}"

当上面的代码执行时，它会产生以下结果：

Area of the box is : 200

类方法 & 类变量

类变量是在类的所有实例中共享的变量。换句话说，类变量的实例可以被所有的对象实例访问。类变量以两个 @ 字符（@@）作为前缀，类变量必须在类定义中被初始化，如下面实例所示。

类方法使用 def self.methodname() 定义，类方法以 end 分隔符结尾。类方法可使用带有类名称的 classname.methodname 形式调用，如下面实例所示：

#!/usr/bin/ruby -wclass Box   # 初始化类变量   @@count = 0   def initialize(w,h)      # 给实例变量赋值      @width, @height = w, h      @@count += 1   end   def self.printCount()      puts "Box count is : #@@count"   endend# 创建两个对象box1 = Box.new(10, 20)box2 = Box.new(30, 100)# 调用类方法来输出盒子计数Box.printCount()

当上面的代码执行时，它会产生以下结果：

Box count is : 2

to_s 方法

您定义的任何类都有一个 to_s 实例方法来返回对象的字符串表示形式。下面是一个简单的实例，根据 width 和 height 表示 Box 对象：

#!/usr/bin/ruby -wclass Box   # 构造器方法   def initialize(w,h)      @width, @height = w, h   end   # 定义 to_s 方法   def to_s      "(w:#@width,h:#@height)"  # 对象的字符串格式   endend# 创建对象box = Box.new(10, 20)# 自动调用 to_s 方法puts "String representation of box is : #{box}"

当上面的代码执行时，它会产生以下结果：

String representation of box is : (w:10,h:20)

访问控制

Ruby 为您提供了三个级别的实例方法保护，分别是 public、private 或 protected。Ruby 不在实例和类变量上应用任何访问控制。

• Public 方法： Public 方法可被任意对象调用。默认情况下，方法都是 public 的，除了 initialize 方法总是 private 的。
• Private 方法： Private 方法不能从类外部访问或查看。只有类方法可以访问私有成员。
• Protected 方法： Protected 方法只能被类及其子类的对象调用。访问也只能在类及其子类内部进行。

下面是一个简单的实例，演示了这三种修饰符的语法：

#!/usr/bin/ruby -w# 定义类class Box   # 构造器方法   def initialize(w,h)      @width, @height = w, h   end   # 实例方法默认是 public 的   def getArea      getWidth() * getHeight   end   # 定义 private 的访问器方法   def getWidth      @width   end   def getHeight      @height   end   # make them private   private :getWidth, :getHeight   # 用于输出面积的实例方法   def printArea      @area = getWidth() * getHeight      puts "Big box area is : #@area"   end   # 让实例方法是 protected 的   protected :printAreaend# 创建对象box = Box.new(10, 20)# 调用实例方法a = box.getArea()puts "Area of the box is : #{a}"# 尝试调用 protected 的实例方法box.printArea()

当上面的代码执行时，它会产生以下结果。在这里，第一种方法调用成功，但是第二方法会产生一个问题。

Area of the box is : 200test.rb:42: protected method `printArea' called for #<Box:0xb7f11280 @height=20, @width=10> (NoMethodError)

类的继承

继承，是面向对象编程中最重要的概念之一。继承允许我们根据另一个类定义一个类，这样使得创建和维护应用程序变得更加容易。

继承有助于重用代码和快速执行，不幸的是，Ruby 不支持多继承，但是 Ruby 支持 mixins。mixin 就像是多继承的一个特定实现，在多继承中，只有接口部分是可继承的。

当创建类时，程序员可以直接指定新类继承自某个已有类的成员，这样就不用从头编写新的数据成员和成员函数。这个已有类被称为基类或父类，新类被称为派生类或子类。

Ruby 也提供了子类化的概念，子类化即继承，下面的实例解释了这个概念。扩展一个类的语法非常简单。只要添加一个 < 字符和父类的名称到类语句中即可。例如，下面定义了类 BigBox 是 Box 的子类：

#!/usr/bin/ruby -w# 定义类class Box   # 构造器方法   def initialize(w,h)      @width, @height = w, h   end   # 实例方法   def getArea      @width * @height   endend# 定义子类class BigBox < Box   # 添加一个新的实例方法   def printArea      @area = @width * @height      puts "Big box area is : #@area"   endend# 创建对象box = BigBox.new(10, 20)# 输出面积box.printArea()

当上面的代码执行时，它会产生以下结果：

Big box area is : 200

方法重载

虽然您可以在派生类中添加新的功能，但有时您可能想要改变已经在父类中定义的方法的行为。这时您可以保持方法名称不变，重载方法的功能即可，如下面实例所示：

#!/usr/bin/ruby -w# 定义类class Box   # 构造器方法   def initialize(w,h)      @width, @height = w, h   end   # 实例方法   def getArea      @width * @height   endend# 定义子类class BigBox < Box   # 改变已有的 getArea 方法   def getArea      @area = @width * @height      puts "Big box area is : #@area"   endend# 创建对象box = BigBox.new(10, 20)# 使用重载的方法输出面积box.getArea()

运算符重载

我们希望使用 + 运算符执行两个 Box 对象的向量加法，使用 * 运算符来把 Box 的 width 和 height 相乘，使用一元运算符 - 对 Box 的 width 和 height 求反。下面是一个带有数学运算符定义的 Box 类版本：

class Box  def initialize(w,h) # 初始化 width 和 height    @width,@height = w, h  end  def +(other)         # 定义 + 来执行向量加法    Box.new(@width + other.width, @height + other.height)  end  def -@               # 定义一元运算符 - 来对 width 和 height 求反    Box.new(-@width, -@height)  end  def *(scalar)        # 执行标量乘法    Box.new(@width*scalar, @height*scalar)  endend

冻结对象

有时候，我们想要防止对象被改变。在 Object 中，freeze 方法可实现这点，它能有效地把一个对象变成一个常量。任何对象都可以通过调用 Object.freeze 进行冻结。冻结对象不能被修改，也就是说，您不能改变它的实例变量。

您可以使用 Object.frozen? 方法检查一个给定的对象是否已经被冻结。如果对象已被冻结，该方法将返回 true，否则返回一个 false 值。下面的实例解释了这个概念：

#!/usr/bin/ruby -w# 定义类class Box   # 构造器方法   def initialize(w,h)      @width, @height = w, h   end   # 访问器方法   def getWidth      @width   end   def getHeight      @height   end   # 设置器方法   def setWidth=(value)      @width = value   end   def setHeight=(value)      @height = value   endend# 创建对象box = Box.new(10, 20)# 让我们冻结该对象box.freezeif( box.frozen? )   puts "Box object is frozen object"else   puts "Box object is normal object"end# 现在尝试使用设置器方法box.setWidth = 30box.setHeight = 50# 使用访问器方法x = box.getWidth()y = box.getHeight()puts "Width of the box is : #{x}"puts "Height of the box is : #{y}"

当上面的代码执行时，它会产生以下结果：

Box object is frozen objecttest.rb:20:in `setWidth=': can't modify frozen object (TypeError)        from test.rb:39

类常量

您可以在类的内部定义一个常量，通过把一个直接的数值或字符串值赋给一个变量来定义的，常量的定义不需要使用 @ 或 @@。按照惯例，常量的名称使用大写。

一旦常量被定义，您就不能改变它的值，您可以在类的内部直接访问常量，就像是访问变量一样，但是如果您想要在类的外部访问常量，那么您必须使用 classname::constant，如下面实例所示。

#!/usr/bin/ruby -w# 定义类class Box   BOX_COMPANY = "TATA Inc"   BOXWEIGHT = 10   # 构造器方法   def initialize(w,h)      @width, @height = w, h   end   # 实例方法   def getArea      @width * @height   endend# 创建对象box = Box.new(10, 20)# 调用实例方法a = box.getArea()puts "Area of the box is : #{a}"puts Box::BOX_COMPANYputs "Box weight is: #{Box::BOXWEIGHT}"

当上面的代码执行时，它会产生以下结果：

Area of the box is : 200TATA IncBox weight is: 10

类常量可被继承，也可像实例方法一样被重载。

使用 allocate 创建对象

可能有一种情况，您想要在不调用对象构造器 initialize 的情况下创建对象，即，使用 new 方法创建对象，在这种情况下，您可以调用 allocate 来创建一个未初始化的对象，如下面实例所示：

#!/usr/bin/ruby -w# 定义类class Box   attr_accessor :width, :height   # 构造器方法   def initialize(w,h)      @width, @height = w, h   end   # 实例方法   def getArea      @width * @height   endend# 使用 new 创建对象box1 = Box.new(10, 20)# 使用 allocate 创建两一个对象box2 = Box.allocate# 使用 box1 调用实例方法a = box1.getArea()puts "Area of the box is : #{a}"# 使用 box2 调用实例方法a = box2.getArea()puts "Area of the box is : #{a}"

当上面的代码执行时，它会产生以下结果：

Area of the box is : 200test.rb:14: warning: instance variable @width not initializedtest.rb:14: warning: instance variable @height not initializedtest.rb:14:in `getArea': undefined method `*'    for nil:NilClass (NoMethodError) from test.rb:29

类信息

如果类定义是可执行代码，这意味着，它们可在某个对象的上下文中执行，self 必须引用一些东西。让我们来看看下面的实例：.

#!/usr/bin/ruby -wclass Box   # 输出类信息   puts "Type of self = #{self.type}"   puts "Name of self = #{self.name}"end

当上面的代码执行时，它会产生以下结果：

Type of self = ClassName of self = Box

这意味着类定义可通过把该类作为当前对象来执行，同时也意味着元类和父类中的该方法在方法定义执行期间是可用的。

Ruby 正则表达式

语法

正则表达式从字面上看是一种介于斜杠之间或介于跟在 %r 后的任意分隔符之间的模式，如下所示：

/pattern//pattern/im    # 可以指定选项%r!/usr/local! # 一般的分隔的正则表达式

实例

#!/usr/bin/rubyline1 = "Cats are smarter than dogs";line2 = "Dogs also like meat";if ( line1 =~ /Cats(.*)/ )  puts "Line1 contains Cats"endif ( line2 =~ /Cats(.*)/ )  puts "Line2 contains  Dogs"end

这将产生以下结果：

Line1 contains Cats

正则表达式修饰符

正则表达式从字面上看可能包含一个可选的修饰符，用于控制各方面的匹配。修饰符在第二个斜杠字符后指定，如上面实例所示。下标列出了 可能的修饰符：

就像字符串通过 %Q 进行分隔一样，Ruby 允许您以 %r 作为正则表达式的开头，后面跟着任意分隔符。这在描述包含大量您不想转义的斜杠字符时非常有用。

# 下面匹配单个斜杠字符，不转义%r|/|               # Flag 字符可通过下面的语法进行匹配%r[</(.*)>]i  

正则表达式模式

除了控制字符，(+ ? . * ^ $ ( ) [ ] { } | )，其他所有字符都匹配本身。您可以通过在控制字符前放置一个反斜杠来对控制字符进行转义。

下表列出了 Ruby 中可用的正则表达式语法。

正则表达式实例

字符

字符类

特殊字符类

重复

非贪婪重复

这会匹配最小次数的重复。

通过圆括号进行分组

反向引用

这会再次匹配之前匹配过的分组。

替换

锚

这需要指定匹配位置。

圆括号的特殊语法

搜索和替换

sub 和 gsub 及它们的替代变量 sub! 和 gsub! 是使用正则表达式时重要的字符串方法。

所有这些方法都是使用正则表达式模式执行搜索与替换操作。sub 和 sub! 替换模式的第一次出现，gsub 和 gsub! 替换模式的所有出现。

sub 和 gsub 返回一个新的字符串，保持原始的字符串不被修改，而 sub! 和 gsub! 则会修改它们调用的字符串。

下面是一个实例：

#!/usr/bin/ruby# -*- coding: UTF-8 -*-phone = "138-3453-1111 #这是一个电话号码"# 删除 Ruby 的注释phone = phone.sub!(/#.*$/, "")   puts "电话号码 : #{phone}"# 移除数字以外的其他字符phone = phone.gsub!(/D/, "")    puts "电话号码 : #{phone}"

这将产生以下结果：

电话号码 : 138-3453-1111 电话号码 : 13834531111

下面是另一个实例：

#!/usr/bin/rubytext = "rails are rails, really good Ruby on Rails"# 把所有的 "rails" 改为 "Rails"text.gsub!("rails", "Rails")# 把所有的单词 "Rails" 都改成首字母大写text.gsub!(/rails/, "Rails")puts "#{text}"

这将产生以下结果：

Rails are Rails, really good Ruby on Rails

Ruby 数据库访问 - DBI 教程

DBI 应用架构

DBI 独立于任何在后台中可用的数据库。无论您使用的是 Oracle、MySQL、Informix，您都可以使用 DBI。下面的架构图清晰地说明了这点。

Ruby DBI 一般的架构使用两个层：

• 数据库接口（DBI）层。该层是独立于数据库，并提供了一系列公共访问方法，方法的使用不分数据库服务器类型。
• 数据库驱动（DBD）层。该层是依赖于数据库，不同的驱动提供了对不同的数据库引擎的访问。MySQL、PostgreSQL、InterBase、Oracle 等分别使用不同的驱动。每个驱动都负责解释来自 DBI 层的请求，并把这些请求映射为适用于给定类型的数据库服务器的请求。

先决条件

如果您想要编写 Ruby 脚本来访问 MySQL 数据库，您需要先安装 Ruby MySQL 模块。

该模块是一个 DBD，可从 http://www.tmtm.org/en/mysql/ruby/ 上下载。

获取并安装 Ruby/DBI

您可以从下面的链接下载并安装 Ruby DBI 模块：

在开始安装之前，请确保您拥有 root 权限。现在，请安装下面的步骤进行安装：

步骤 1

$ tar zxf dbi-0.2.0.tar.gz

步骤 2

进入目录 dbi-0.2.0，在目录中使用 setup.rb 脚本进行配置。最常用的配置命令是 config 参数后不跟任何参数。该命令默认配置为安装所有的驱动。

$ ruby setup.rb config

更具体地，您可以使用 --with 选项来列出了您要使用的特定部分。例如，如果只想配置主要的 DBI 模块和 MySQL DBD 层驱动，请输入下面的命令：

$ ruby setup.rb config --with=dbi,dbd_mysql

步骤 3

最后一步是建立驱动器，使用下面命令进行安装：

$ ruby setup.rb setup$ ruby setup.rb install

数据库连接

假设我们使用的是 MySQL 数据库，在连接数据库之前，请确保：

• 您已经创建了一个数据库 TESTDB。
• 您已经在 TESTDB 中创建了表 EMPLOYEE。
• 该表带有字段 FIRST_NAME、LAST_NAME、AGE、SEX 和 INCOME。
• 设置用户 ID "testuser" 和密码 "test123" 来访问 TESTDB
• 已经在您的机器上正确地安装了 Ruby 模块 DBI。
• 您已经看过 MySQL 教程，理解了 MySQL 基础操作。

下面是连接 MySQL 数据库 "TESTDB" 的实例：

#!/usr/bin/ruby -wrequire "dbi"begin     # 连接到 MySQL 服务器     dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",                        "testuser", "test123")     # 获取服务器版本字符串，并显示     row = dbh.select_one("SELECT VERSION()")     puts "Server version: " + row[0]rescue DBI::DatabaseError => e     puts "An error occurred"     puts "Error code:    #{e.err}"     puts "Error message: #{e.errstr}"ensure     # 断开与服务器的连接     dbh.disconnect if dbhend

当运行这段脚本时，将会在 Linux 机器上产生以下结果。

Server version: 5.0.45

如果建立连接时带有数据源，则返回数据库句柄（Database Handle），并保存到 dbh 中以便后续使用，否则 dbh 将被设置为 nil 值，e.err 和 e::errstr 分别返回错误代码和错误字符串。

最后，在退出这段程序之前，请确保关闭数据库连接，释放资源。

INSERT 操作

当您想要在数据库表中创建记录时，需要用到 INSERT 操作。

一旦建立了数据库连接，我们就可以准备使用 do 方法或 prepare 和 execute 方法创建表或创建插入数据表中的记录。

使用 do 语句

不返回行的语句可通过调用 do 数据库处理方法。该方法带有一个语句字符串参数，并返回该语句所影响的行数。

dbh.do("DROP TABLE IF EXISTS EMPLOYEE")dbh.do("CREATE TABLE EMPLOYEE (     FIRST_NAME  CHAR(20) NOT NULL,     LAST_NAME  CHAR(20),     AGE INT,       SEX CHAR(1),     INCOME FLOAT )" );

同样地，您可以执行 SQL INSERT 语句来创建记录插入 EMPLOYEE 表中。

#!/usr/bin/ruby -wrequire "dbi"begin     # 连接到 MySQL 服务器     dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",                      "testuser", "test123")     dbh.do( "INSERT INTO EMPLOYEE(FIRST_NAME,                   LAST_NAME,                    AGE,         SEX,          INCOME)          VALUES ('Mac', 'Mohan', 20, 'M', 2000)" )     puts "Record has been created"     dbh.commitrescue DBI::DatabaseError => e     puts "An error occurred"     puts "Error code:    #{e.err}"     puts "Error message: #{e.errstr}"     dbh.rollbackensure     # 断开与服务器的连接     dbh.disconnect if dbhend

使用 prepare 和 execute

您可以使用 DBI 的 prepare 和 execute 方法来执行 Ruby 代码中的 SQL 语句。

创建记录的步骤如下：

• 准备带有 INSERT 语句的 SQL 语句。这将通过使用 prepare 方法来完成。
• 执行 SQL 查询，从数据库中选择所有的结果。这将通过使用 execute 方法来完成。
• 释放语句句柄。这将通过使用 finish API 来完成。
• 如果一切进展顺利，则 commit 该操作，否则您可以 rollback 完成交易。

下面是使用这两种方法的语法：

sth = dbh.prepare(statement)sth.execute   ... zero or more SQL operations ...sth.finish

这两种方法可用于传 bind 值给 SQL 语句。有时候被输入的值可能未事先给出，在这种情况下，则会用到绑定值。使用问号（?）替代实际值，实际值通过 execute() API 来传递。

下面的实例在 EMPLOYEE 表中创建了两个记录：

#!/usr/bin/ruby -wrequire "dbi"begin     # 连接到 MySQL 服务器     dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",                        "testuser", "test123")     sth = dbh.prepare( "INSERT INTO EMPLOYEE(FIRST_NAME,                   LAST_NAME,                    AGE,          SEX,          INCOME)                   VALUES (?, ?, ?, ?, ?)" )     sth.execute('John', 'Poul', 25, 'M', 2300)     sth.execute('Zara', 'Ali', 17, 'F', 1000)     sth.finish     dbh.commit     puts "Record has been created"rescue DBI::DatabaseError => e     puts "An error occurred"     puts "Error code:    #{e.err}"     puts "Error message: #{e.errstr}"     dbh.rollbackensure     # 断开与服务器的连接     dbh.disconnect if dbhend

如果同时使用多个 INSERT，那么先准备一个语句，然后在一个循环中多次执行它要比通过循环每次调用 do 有效率得多。

READ 操作

对任何数据库的 READ 操作是指从数据库中获取有用的信息。

一旦建立了数据库连接，我们就可以准备查询数据库。我们可以使用 do 方法或 prepare 和 execute 方法从数据库表中获取值。

获取记录的步骤如下：

• 基于所需的条件准备 SQL 查询。这将通过使用 prepare 方法来完成。
• 执行 SQL 查询，从数据库中选择所有的结果。这将通过使用 execute 方法来完成。
• 逐一获取结果，并输出这些结果。这将通过使用 fetch 方法来完成。
• 释放语句句柄。这将通过使用 finish 方法来完成。

下面的实例从 EMPLOYEE 表中查询所有工资（salary）超过 1000 的记录。

#!/usr/bin/ruby -wrequire "dbi"begin     # 连接到 MySQL 服务器     dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",                        "testuser", "test123")     sth = dbh.prepare("SELECT * FROM EMPLOYEE                         WHERE INCOME > ?")     sth.execute(1000)     sth.fetch do |row|        printf "First Name: %s, Last Name : %s
", row[0], row[1]        printf "Age: %d, Sex : %s
", row[2], row[3]        printf "Salary :%d 

", row[4]     end     sth.finishrescue DBI::DatabaseError => e     puts "An error occurred"     puts "Error code:    #{e.err}"     puts "Error message: #{e.errstr}"ensure     # 断开与服务器的连接     dbh.disconnect if dbhend

这将产生以下结果：

First Name: Mac, Last Name : MohanAge: 20, Sex : MSalary :2000First Name: John, Last Name : PoulAge: 25, Sex : MSalary :2300

还有很多从数据库获取记录的方法，如果您感兴趣，可以查看 Ruby DBI Read 操作。

Update 操作

对任何数据库的 UPDATE 操作是指更新数据库中一个或多个已有的记录。下面的实例更新 SEX 为 'M' 的所有记录。在这里，我们将把所有男性的 AGE 增加一岁。这将分为三步：

• 基于所需的条件准备 SQL 查询。这将通过使用 prepare 方法来完成。
• 执行 SQL 查询，从数据库中选择所有的结果。这将通过使用 execute 方法来完成。
• 释放语句句柄。这将通过使用 finish 方法来完成。
• 如果一切进展顺利，则 commit 该操作，否则您可以 rollback 完成交易。

#!/usr/bin/ruby -wrequire "dbi"begin     # 连接到 MySQL 服务器     dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",                       "testuser", "test123")     sth = dbh.prepare("UPDATE EMPLOYEE SET AGE = AGE + 1                        WHERE SEX = ?")     sth.execute('M')     sth.finish     dbh.commitrescue DBI::DatabaseError => e     puts "An error occurred"     puts "Error code:    #{e.err}"     puts "Error message: #{e.errstr}"     dbh.rollbackensure     # 断开与服务器的连接     dbh.disconnect if dbhend

DELETE 操作

当您想要从数据库中删除记录时，需要用到 DELETE 操作。下面的实例从 EMPLOYEE 中删除 AGE 超过 20 的所有记录。该操作的步骤如下：

• 基于所需的条件准备 SQL 查询。这将通过使用 prepare 方法来完成。
• 执行 SQL 查询，从数据库中删除所需的记录。这将通过使用 execute 方法来完成。
• 释放语句句柄。这将通过使用 finish 方法来完成。
• 如果一切进展顺利，则 commit 该操作，否则您可以 rollback 完成交易。

#!/usr/bin/ruby -wrequire "dbi"begin     # 连接到 MySQL 服务器     dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",                        "testuser", "test123")     sth = dbh.prepare("DELETE FROM EMPLOYEE                         WHERE AGE > ?")     sth.execute(20)     sth.finish     dbh.commitrescue DBI::DatabaseError => e     puts "An error occurred"     puts "Error code:    #{e.err}"     puts "Error message: #{e.errstr}"     dbh.rollbackensure     # 断开与服务器的连接     dbh.disconnect if dbhend

执行事务

事务是一种确保交易一致性的机制。事务应具有下列四种属性：

• 原子性（Atomicity）：事务的原子性指的是，事务中包含的程序作为数据库的逻辑工作单位，它所做的对数据修改操作要么全部执行，要么完全不执行。
• 一致性（Consistency）：事务的一致性指的是在一个事务执行之前和执行之后数据库都必须处于一致性状态。假如数据库的状态满足所有的完整性约束，就说该数据库是一致的。
• 隔离性（Isolation）：事务的隔离性指并发的事务是相互隔离的，即一个事务内部的操作及正在操作的数据必须封锁起来，不被其它企图进行修改的事务看到。
• 持久性（Durability）：事务的持久性意味着当系统或介质发生故障时，确保已提交事务的更新不能丢失。即一旦一个事务提交，它对数据库中数据的改变应该是永久性的，耐得住任何数据库系统故障。持久性通过数据库备份和恢复来保证。

DBI 提供了两种执行事务的方法。一种是 commit 或 rollback 方法，用于提交或回滚事务。还有一种是 transaction 方法，可用于实现事务。接下来我们来介绍这两种简单的实现事务的方法：

方法 I

第一种方法使用 DBI 的 commit 和 rollback 方法来显式地提交或取消事务：

   dbh['AutoCommit'] = false # 设置自动提交为 false.   begin     dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1              WHERE FIRST_NAME = 'John'")     dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1              WHERE FIRST_NAME = 'Zara'")     dbh.commit   rescue     puts "transaction failed"     dbh.rollback   end   dbh['AutoCommit'] = true

方法 II

第二种方法使用 transaction 方法。这个方法相对简单些，因为它需要一个包含构成事务语句的代码块。transaction 方法执行块，然后根据块是否执行成功，自动调用 commit 或 rollback：

   dbh['AutoCommit'] = false # 设置自动提交为 false   dbh.transaction do |dbh|     dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1              WHERE FIRST_NAME = 'John'")     dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1              WHERE FIRST_NAME = 'Zara'")   end   dbh['AutoCommit'] = true

COMMIT 操作

Commit 是一种标识数据库已完成更改的操作，在这个操作后，所有的更改都不可恢复。

下面是一个调用 commit 方法的简单实例。

     dbh.commit

ROLLBACK 操作

如果您不满意某个或某几个更改，您想要完全恢复这些更改，则使用 rollback 方法。

下面是一个调用 rollback 方法的简单实例。

     dbh.rollback

断开数据库

如需断开数据库连接，请使用 disconnect API。

    dbh.disconnect

如果用户通过 disconnect 方法关闭了数据库连接，DBI 会回滚所有未完成的事务。但是，不需要依赖于任何 DBI 的实现细节，您的应用程序就能很好地显式调用 commit 或 rollback。

处理错误

有许多不同的错误来源。比如在执行 SQL 语句时的语法错误，或者是连接失败，又或者是对一个已经取消的或完成的语句句柄调用 fetch 方法。

如果某个 DBI 方法失败，DBI 会抛出异常。DBI 方法会抛出任何类型的异常，但是最重要的两种异常类是 DBI::InterfaceError 和 DBI::DatabaseError。

这些类的 Exception 对象有 err、errstr 和 state 三种属性，分表代表了错误号、一个描述性的错误字符串和一个标准的错误代码。属性具体说明如下：

• err：返回所发生的错误的整数表示法，如果 DBD 不支持则返回 nil。例如，Oracle DBD 返回 ORA-XXXX 错误消息的数字部分。
• errstr：返回所发生的错误的字符串表示法。
• state：返回所发生的错误的 SQLSTATE 代码。SQLSTATE 是五字符长度的字符串。大多数的 DBD 并不支持它，所以会返回 nil。

在上面的实例中您已经看过下面的代码：

rescue DBI::DatabaseError => e     puts "An error occurred"     puts "Error code:    #{e.err}"     puts "Error message: #{e.errstr}"     dbh.rollbackensure     # 断开与服务器的连接     dbh.disconnect if dbhend

为了获取脚本执行时有关脚本执行内容的调试信息，您可以启用跟踪。为此，您必须首先下载 dbi/trace 模块，然后调用控制跟踪模式和输出目的地的 trace 方法：

require "dbi/trace"..............trace(mode, destination)

mode 的值可以是 0（off）、1、2 或 3，destination 的值应该是一个 IO 对象。默认值分别是 2 和 STDERR。

方法的代码块

有一些创建句柄的方法。这些方法通过代码块调用。使用带有方法的代码块的优点是，它们为代码块提供了句柄作为参数，当块终止时会自动清除句柄。下面是一些实例，有助于理解这个概念。

• DBI.connect ：该方法生成一个数据库句柄，建议在块的末尾调用 disconnect 来断开数据库。
• dbh.prepare ：该方法生成一个语句句柄，建议在块的末尾调用 finish。在块内，您必须调用 execute 方法来执行语句。
• dbh.execute ：该方法与 dbh.prepare 类似，但是 dbh.execute 不需要在块内调用 execute 方法。语句句柄会自动执行。

实例 1

DBI.connect 可带有一个代码块，向它传递数据库句柄，且会在块的末尾自动断开句柄。

dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",                   "testuser", "test123") do |dbh|

实例 2

dbh.prepare 可带有一个代码块，向它传递语句句柄，且会在块的末尾自动调用 finish。

dbh.prepare("SHOW DATABASES") do |sth|       sth.execute       puts "Databases: " + sth.fetch_all.join(", ")end

实例 3

dbh.execute 可带有一个代码块，向它传递语句句柄，且会在块的末尾自动调用 finish。

dbh.execute("SHOW DATABASES") do |sth|   puts "Databases: " + sth.fetch_all.join(", ")end

DBI transaction 方法也可带有一个代码块，这在上面的章节中已经讲解过了。

特定驱动程序的函数和属性

DBI 让数据库驱动程序提供了额外的特定数据库的函数，这些函数可被用户通过任何 Handle 对象的 func 方法进行调用。

使用 []= or [] 方法可以设置或获取特定驱动程序的属性。

DBD::Mysql 实现了下列特定驱动程序的函数：

实例

#!/usr/bin/rubyrequire "dbi"begin   # 连接到 MySQL 服务器   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",                        "testuser", "test123")    puts dbh.func(:client_info)   puts dbh.func(:client_version)   puts dbh.func(:host_info)   puts dbh.func(:proto_info)   puts dbh.func(:server_info)   puts dbh.func(:thread_id)   puts dbh.func(:stat)rescue DBI::DatabaseError => e   puts "An error occurred"   puts "Error code:    #{e.err}"   puts "Error message: #{e.errstr}"ensure   dbh.disconnect if dbhend

这将产生以下结果：

5.0.4550045Localhost via UNIX socket105.0.45150621Uptime: 384981  Threads: 1  Questions: 1101078  Slow queries: 4 Opens: 324  Flush tables: 1  Open tables: 64  Queries per second avg: 2.860

Ruby CGI 编程

Ruby 是一门通用的语言，不仅仅是一门应用于WEB开发的语言，但 Ruby 在WEB应用及WEB工具中的开发是最常见的。

使用Ruby您不仅可以编写自己的SMTP服务器，FTP程序，或Ruby Web服务器，而且还可以使用Ruby进行CGI编程。

接下来，让我们花点时间来学校Ruby的CGI编辑。

网页浏览

为了更好的了解CGI是如何工作的，我们可以从在网页上点击一个链接或URL的流程：

• 1、使用你的浏览器访问URL并连接到HTTP web 服务器。
• 2、Web服务器接收到请求信息后会解析URL，并查找访问的文件在服务器上是否存在，如果存在返回文件的内容，否则返回错误信息。
• 3、浏览器从服务器上接收信息，并显示接收的文件或者错误信息。

CGI程序可以是 Ruby 脚本，Python 脚本，PERL 脚本，SHELL 脚本，C 或者 C++ 程序等。

CGI架构图

Web服务器支持及配置

在你进行CGI编程前，确保您的Web服务器支持CGI及已经配置了CGI的处理程序。

Apache 支持CGI 配置：

设置好CGI目录：

ScriptAlias /cgi-bin/ /var/www/cgi-bin/

所有的HTTP服务器执行CGI程序都保存在一个预先配置的目录。这个目录被称为CGI目录，并按照惯例，它被命名为/var/www/cgi-bin目录。

CGI文件的扩展名为.cgi，Ruby 也可以使用 .rb 扩展名。

默认情况下，Linux服务器配置运行的cgi-bin目录中为/var/www。

如果你想指定其他运行CGI脚本的目录，可以修改httpd.conf配置文件，如下所示：

<Directory "/var/www/cgi-bin">   AllowOverride None   Options +ExecCGI   Order allow,deny   Allow from all</Directory>

在 AddHandler 中添加 .rb 后缀，这样我们就可以访问 .rb 结尾的 Ruby 脚本文件：

AddHandler cgi-script .cgi .pl .rb

编写 CGI 脚本

最脚本的 Ruby CGI 代码如下所示：

#!/usr/bin/ruby puts "HTTP/1.0 200 OK" puts "Content-type: text/html " puts "This is a test"

你可以将该代码保持到 test.cgi 文件中，上次到服务器并赋予足够权限，即可作为 CGI 脚本执行。

如果你站的的地址为http://www.example.com/ ，即可用过http://www.example.com/test.cgi 访问该程序，输出结果为： "This is a test."。

浏览器访问该网址后，Web 服务器会在站点目录下找到 test.cgi文件，然后通过Ruby解析器来解析脚本代码并访问HTML文档。

使用 cgi.rb

Ruby 可以调用 CGI 库来编写更复杂的CGI脚本。

以下代码调用了 CGI 库来创建一个脚本的CGI脚本。

#!/usr/bin/rubyrequire 'cgi'cgi = CGI.newputs cgi.headerputs "<html><body>This is a test</body></html>"

以下代码中，创建了CGI 对象并打印头部信息。

表单处理

使用CGI库可以通过两种方式获取表单提交（或URL中的参数）的数据， 例如URL：/cgi-bin/test.cgi?FirstName=Zara&LastName=Ali。

你可以使用 CGI#[] 来直接获取参数FirstName和LastName：

#!/usr/bin/rubyrequire 'cgi'cgi = CGI.newcgi['FirstName'] # =>  ["Zara"]cgi['LastName']  # =>  ["Ali"]

另外一种获取表单数据的方法：

#!/usr/bin/rubyrequire 'cgi'cgi = CGI.newh = cgi.params  # =>  {"FirstName"=>["Zara"],"LastName"=>["Ali"]}h['FirstName']  # =>  ["Zara"]h['LastName']   # =>  ["Ali"]

以下代码用于检索所有的键值：

#!/usr/bin/rubyrequire 'cgi'cgi = CGI.newcgi.keys         # =>  ["FirstName", "LastName"]

如果表单包含了多个相同名称的字段，则该相同字段的值将保存在数组中。

以下实例中，指定表单中三个相同的字段"name"，值分别为 "Zara", "Huma" 和 "Nuha":

#!/usr/bin/rubyrequire 'cgi'cgi = CGI.newcgi['name']        # => "Zara"cgi.params['name'] # => ["Zara", "Huma", "Nuha"]cgi.keys           # => ["name"]cgi.params         # => {"name"=>["Zara", "Huma", "Nuha"]}

注意：Ruby 会自动判断 GET 和 POST 方法，所以无需对两种方法区别对待。

以下是相关的HML代码：

<html><body><form method="POST" action="http://www.example.com/test.cgi">First Name :<input type="text" name="FirstName" value="" /><br />Last Name :<input type="text" name="LastName" value="" /> <input type="submit" value="Submit Data" /></form></body></html>

创建 Form 表单和 HTML

CGI 包含了大量的方法来创建 HTML，每个HTML标签都有相对应的方法。 在使用这些方法前，比必须通过 CGI.new 来创建 CGI 对象。

为了使标签的嵌套更加的简单，这些方法将内容作为了代码块，代码块将返回字符串作为标签的内容。如下所示：

#!/usr/bin/rubyrequire "cgi"cgi = CGI.new("html4")cgi.out{   cgi.html{      cgi.head{ "
"+cgi.title{"This Is a Test"} } +      cgi.body{ "
"+         cgi.form{"
"+            cgi.hr +            cgi.h1 { "A Form: " } + "
"+            cgi.textarea("get_text") +"
"+            cgi.br +            cgi.submit         }      }   }}

字符串转义

当你在处理 URL 中的参数或者 HTML 表单数据时，需要对指定的特殊字符进行转义，如：引号（"）,反斜杠(/)。

Ruby CGI 对象提供了CGI.escape 和 CGI.unescape 方法来处理这些特殊字符的转义：

#!/usr/bin/rubyrequire 'cgi'puts CGI.escape(Zara Ali/A Sweet & Sour Girl")

以上代码执行结果如下：

#!/usr/bin/rubyrequire 'cgi'puts CGI.escape(Zara Ali/A Sweet & Sour Girl")

另一组实例：

#!/usr/bin/rubyrequire 'cgi'puts CGI.escapeHTML('<h1>Zara Ali/A Sweet & Sour Girl</h1>')

以上代码执行结果如下：

<h1>Zara Ali/A Sweet & Sour Girl</h1>'

CGI 类中常用的方法

以下是Ruby中完整的CGI类的相关方法

• Ruby CGI - 标准 CGI 库相关方法

Cookies 和 Sessions

• Ruby CGI Cookies - 如何处理 CGI Cookies.
• Ruby CGI Sessions - 如何处理 CGI sessions.

Ruby CGI方法

以下为CGI类的方法列表：

CGI 实例化方法

以下实例中我们将 CGI::new 的对象赋值给 c 变量，方法列表如下：

HTML 生成方法

你可以再 CGI 实例中使用相应的 HTML 标签名来创建 HTML 标签，实例如下：

#!/usr/bin/rubyrequire "cgi"cgi = CGI.new("html4")cgi.out{   cgi.html{      cgi.head{ "
"+cgi.title{"This Is a Test"} } +      cgi.body{ "
"+         cgi.form{"
"+            cgi.hr +            cgi.h1 { "A Form: " } + "
"+            cgi.textarea("get_text") +"
"+            cgi.br +            cgi.submit         }      }   }}

CGI 对象属性

你可以再 CGI 实例中使用以下属性：

Ruby CGI Cookies

HTTP协议是无状态协议。但对于一个商业网站，它需要保持不同的页面间的会话信息。

如用户在网站注册过程中需要跳转页面，但又要保证之前填写的信息部丢失。

这种情况下 Cookie 很好的帮我们解决了问题。

Cookie 是如何工作的？

写入和读取

Cookies集合是附属于Response对象及Request对象的数据集合，使用时需要在前面加上Response或Request。

用于给客户机发送Cookies的语法通常为：

当给不存在的Cookies集合设置时，就会在客户机创建，如果该Cookies己存在，则会被代替。由于Cookies是作为HTTP传输的头信息的一部分发给客户机的，所以向客户机发送Cookies的代码一般放在发送给浏览器的HTML文件的标记之前。

如果用户要读取Cookies，则必须使用Request对象的Cookies集合，其使用方法是： 需要注意的是，只有在服务器未被下载任何数据给浏览器前，浏览器才能与Server进行Cookies集合的数据交换，一旦浏览器开始接收Server所下载的数据，Cookies的数据交换则停止，为了避免错误，要在程序和前面加上response.Buffer=True。

集合的属性

• 1.Expires属性：此属性用来给Cookies设置一个期限，在期限内只要打开网页就可以调用被保存的Cookies，如果过了此期限Cookies就自动被删除。如： 设定Cookies的有效期到2004年4月1日，到时将自动删除。如果一个Cookies没有设定有效期，则其生命周期从打开浏览器开始，到关闭浏览器结束，每次运行后生命周期将结束，下次运行将重新开始。
• 2.Domain属性：这个属性定义了Cookies传送数据的唯一性。若只将某Cookies传送给_blank">搜狐主页时，则可使用如下代码：
• 3.Path属性：定义了Cookies只发给指定的路径请求，如果Path属性没有被设置，则使用应用软件的缺省路径。
• 4.Secure属性：指定Cookies能否被用户读取。
• 5、Name=Value : Cookies是以键值对的形式进行设置和检索的。

Ruby 中处理Cookies

你可以创建一个名为 cookie 的对象并存储文本信息，将该信息发送至浏览器，调用 CGI.out 设置cookie的头部：

#!/usr/bin/rubyrequire "cgi"cgi = CGI.new("html4")cookie = CGI::Cookie.new('name' => 'mycookie',                         'value' => 'Zara Ali',                         'expires' => Time.now + 3600)cgi.out('cookie' => cookie) do   cgi.head + cgi.body { "Cookie stored" }end

接下来我们回到这个页面，并查找cookie值，如下所示：

#!/usr/bin/rubyrequire "cgi"cgi = CGI.new("html4")cookie = cgi.cookies['mycookie']cgi.out('cookie' => cookie) do   cgi.head + cgi.body { cookie[0] }end

CGI::Cookie对象实例化时包含以下参数：

Ruby CGI Sessions

CGI::Session 可以为用户和CGI环境保存持久的会话状态，会话使用后需要关闭，这样可以保证数据写入到存储当中，当会话完成后，你需要删除该数据。

#!/usr/bin/rubyrequire 'cgi'require 'cgi/session'cgi = CGI.new("html4")sess = CGI::Session.new( cgi, "session_key" => "a_test",                              "prefix" => "rubysess.")lastaccess = sess["lastaccess"].to_ssess["lastaccess"] = Time.nowif cgi['bgcolor'][0] =~ /[a-z]/  sess["bgcolor"] = cgi['bgcolor']endcgi.out{  cgi.html {    cgi.body ("bgcolor" => sess["bgcolor"]){      "The background of this page"    +      "changes based on the 'bgcolor'" +      "each user has in session."      +      "Last access time: #{lastaccess}"    }  }}

访问 "/cgi-bin/test.cgi?bgcolor=red" 将跳转到指定背景颜色的页面。

会话数据存在在服务器的临时文件目录中，prefix 参数指定了会话的前缀，将作为临时文件的前缀。这样你在服务器上可以轻松的识别不同的会话临时文件。

CGI::Session 类

CGI::Session 保持了用户与 CGI 环境的持久状态。 会话可以在内存中，也可以在硬盘上。

类方法

Ruby 类 Class CGI::Session 提供了简单的方法来创建 session:

CGI::Session::new( cgi[, option])

启用一个新的 CGI 会话并返回相应的 CGI::Session 对象。选项可以是可选的哈希，可以是以下值：

• session_key: 键名保存会话 默认为 _session_id。
• session_id: 唯一的会话 ID。自动生成
• new_session: 如果为true，为当前会话创建一个新的Session id。 如果为 false, 通过 session_id 使用已存在的 session 标识。 如果省略该参数，如果可用则使用现有的会话，否则创建一个新的。
• database_manager: 用于保存 sessions 的类，可以是 CGI::Session::FileStore or CGI::Session::MemoryStore。默认为 FileStore。
• tmpdir: 对于 FileStore, 为 session 的错存储目录。
• prefix: 对于 FileStore, 为 session 文件的前缀。

实例化方法

Ruby 发送邮件 - SMATP

SMTP（Simple Mail Transfer Protocol）即简单邮件传输协议,它是一组用于由源地址到目的地址传送邮件的规则，由它来控制信件的中转方式。

Ruby提供了 Net::SMTP 来发送邮件，并提供了两个方法 new 和 start:

• new 方法有两个参数：
  • server name 默认为 localhost
  • port number 默认为 25
• start 方法有以下参数：
  • server - SMTP 服务器 IP, 默认为 localhost
  • port - 端口号，默认为 25
  • domain - 邮件发送者域名，默认为 ENV["HOSTNAME"]
  • account - 用户名，默认为 nil
  • password - 用户密码，默认为nil
  • authtype - 验证类型，默认为 cram_md5

SMTP 对象实例化方法调用了 sendmail, 参数如下：

• source - 一个字符串或数组或每个迭代器在任一时间中返回的任何东西。
• sender -一个字符串，出现在 email 的表单字段。
• recipients - 一个字符串或字符串数组，表示收件人的地址。

实例

以下提供了简单的Ruby脚本来发送邮件:

require 'net/smtp'message = <<MESSAGE_END From: Private Person <me@fromdomain.com>To: A Test User <test@todomain.com>Subject: SMTP e-mail testThis is a test e-mail message.MESSAGE_ENDNet::SMTP.start('localhost') do |smtp|  smtp.send_message message, 'me@fromdomain.com',                              'test@todomain.com'end

使用Net::SMTP连接到本地机器上的SMTP服务器，使用send_message方法来发送邮件，方法参数为发送者邮件与接收者邮件。

如果你没有运行在本机上的SMTP服务器，您可以使用Net::SMTP与远程SMTP服务器进行通信。如果使用网络邮件服务（如Hotmail或雅虎邮件），您的电子邮件提供者会为您提供发送邮件服务器的详细信息:

Net::SMTP.start('mail.your-domain.com')

以上代码将连接主机为 mail.your-domain.com，端口号为 25的邮件服务器，如果需要填写用户名密码，则代码如下：

Net::SMTP.start('mail.your-domain.com',                 25,                 'localhost',                 'username', 'password' :plain)

以上实例使用了指定的用户名密码连接到主机为 mail.your-domain.com，端口号为 25的邮件服务器。

使用 Ruby 发送 HTML 邮件

Net::SMTP同样提供了支持发送 HTML 格式的邮件。

发送电子邮件时你可以设置MIME版本，文档类型，字符集来发送HTML格式的邮件。

实例

以下实例用于发送 HTML 格式的邮件：

require 'net/smtp'message = <<MESSAGE_END From: Private Person <me@fromdomain.com>To: A Test User <test@todomain.com>MIME-Version: 1.0Content-type: text/htmlSubject: SMTP e-mail testThis is an e-mail message to be sent in HTML format<b>This is HTML message.</b><h1>This is headline.</h1>MESSAGE_ENDNet::SMTP.start('localhost') do |smtp|  smtp.send_message message, 'me@fromdomain.com',                              'test@todomain.com'end

发送带附件的邮件

如果需要发送混合内容的电子邮件，需要设置Content-type为multipart/mixed。 这样就可以在邮件中添加附件内容。

附件在传输前需要使用 pack("m") 函数将其内容转为 base64 格式。

实例

以下实例将发送附件为 /tmp/test.txt 的邮件：

require 'net/smtp'filename = "/tmp/test.txt"# 读取文件并编码为base64格式filecontent = File.read(filename)encodedcontent = [filecontent].pack("m")   # base64marker = "AUNIQUEMARKER"body =<<EOFThis is a test email to send an attachement.EOF# 定义主要的头部信息part1 =<<EOFFrom: Private Person <me@fromdomain.net>To: A Test User <test@todmain.com>Subject: Sending AttachementMIME-Version: 1.0Content-Type: multipart/mixed; boundary=#{marker}--#{marker}EOF# 定义消息动作part2 =<<EOFContent-Type: text/plainContent-Transfer-Encoding:8bit#{body}--#{marker}EOF# 定义附件部分part3 =<<EOFContent-Type: multipart/mixed; name="#{filename}"Content-Transfer-Encoding:base64Content-Disposition: attachment; filename="#{filename}"#{encodedcontent}--#{marker}--EOFmailtext = part1 + part2 + part3# 发送邮件begin   Net::SMTP.start('localhost') do |smtp|     smtp.sendmail(mailtext, 'me@fromdomain.net',                          ['test@todmain.com'])  endrescue Exception => e    print "Exception occured: " + e  end