Ruby - 快速指南

---

Ruby - 概述

Ruby 是一种纯粹的面向对象的编程语言。它是由日本松本幸弘于1993年创建的。

您可以在 Ruby 邮件列表www.ruby-lang.org上找到 Yukihiro Matsumoto 这个名字。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 的语法与许多编程语言（例如 C++ 和 Perl）类似。

• Ruby 具有很强的可扩展性，用 Ruby 编写的大型程序很容易维护。

• Ruby 可用于开发 Internet 和 Intranet 应用程序。

• Ruby 可以安装在 Windows 和 POSIX 环境中。

• Ruby 支持许多 GUI 工具，例如 Tcl/Tk、GTK 和 OpenGL。

• Ruby 可以轻松连接到 DB2、MySQL、Oracle 和 Sybase。

• Ruby 拥有丰富的内置函数，可以直接在 Ruby 脚本中使用。

您需要的工具

为了执行本教程中讨论的示例，您需要一台最新的计算机，例如 Intel Core i3 或 i5，至少具有 2GB RAM（建议 4GB RAM）。您还需要以下软件 -

• Linux 或 Windows 95/98/2000/NT 或 Windows 7 操作系统。

• Apache 1.3.19-5 Web 服务器。

• Internet Explorer 5.0 或更高版本的网络浏览器。

• 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 计算机，则可以使用任何简单的文本编辑器，例如记事本或 Edit plus。

• VIM（Vi IMproved）是一个非常简单的文本编辑器。这在几乎所有 Unix 机器上都可用，现在 Windows 上也可用。否则，您可以使用您最喜欢的 vi 编辑器来编写 Ruby 程序。

• RubyWin是一个适用于 Windows 的 Ruby 集成开发环境 (IDE)。

• 对于 Windows 用户来说，Ruby 开发环境（RDE）也是一个非常好的 IDE。

交互式Ruby (IRb)

Interactive Ruby (IRb) 提供了一个用于实验的 shell。在 IRb shell 中，您可以立即逐行查看表达式结果。

该工具随 Ruby 安装一起提供，因此您无需执行额外操作即可让 IRb 正常工作。

只需在命令提示符处输入irb ，交互式 Ruby 会话就会启动，如下所示 -

$irb
irb 0.6.1(99/09/16)
irb(main):001:0> def hello
irb(main):002:1> out = "Hello World"
irb(main):003:1> puts out
irb(main):004:1> end
nil
irb(main):005:0> hello
Hello World
nil
irb(main):006:0>

不要担心我们在这里做了什么。您将在后续章节中学习所有这些步骤。

下一步是什么？

我们假设现在您已经有了一个可用的 Ruby 环境，并且您已准备好编写第一个 Ruby 程序。下一章将教你如何编写 Ruby 程序。

Ruby - 语法

让我们用 ruby​​ 编写一个简单的程序。所有 ruby​​ 文件都有扩展名.rb。因此，将以下源代码放入 test.rb 文件中。

现场演示

#!/usr/bin/ruby -w

puts "Hello, Ruby!";

在这里，我们假设 /usr/bin 目录中有可用的 Ruby 解释器。现在，尝试按如下方式运行该程序 -

$ ruby test.rb

这将产生以下结果 -

Hello, Ruby!

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

Ruby 程序中的空白

空格和制表符等空白字符在 Ruby 代码中通常会被忽略，除非它们出现在字符串中。然而，有时它们被用来解释模棱两可的陈述。当启用 -w 选项时，此类解释会产生警告。

例子

a + b is interpreted as a+b ( Here a is a local variable)
a  +b is interpreted as a(+b) ( Here a is a method call)

Ruby 程序中的行结尾

Ruby 将分号和换行符解释为语句的结束。但是，如果 Ruby 在行尾遇到运算符，例如 +、- 或反斜杠，则它们表示语句的继续。

Ruby标识符

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

Ruby 标识符名称可以由字母数字字符和下划线字符 (_) 组成。

保留字

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

这里的 Ruby 文档

“Here Document”是指从多行构建字符串。在 << 之后，您可以指定一个字符串或标识符来终止字符串文字，并且当前行之后直到终止符的所有行都是该字符串的值。

如果终止符被引号引起来，则引号的类型决定了面向行的字符串文字的类型。请注意，<< 和终止符之间不能有空格。

这是不同的例子 -

现场演示

#!/usr/bin/ruby -w

print <<EOF
   This is the first way of creating
   here document ie. multiple line string.
EOF

print <<"EOF";                # same as above
   This is the second way of creating
   here document ie. multiple line string.
EOF

print <<`EOC`                 # execute commands
	echo hi there
	echo lo there
EOC

print <<"foo", <<"bar"  # you can stack them
	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 there
lo there
      I said foo.
      I said bar.

Ruby BEGIN 语句

句法

BEGIN {
   code
}

声明在程序运行之前要调用的代码。

例子

现场演示

#!/usr/bin/ruby

puts "This is main Ruby Program"

BEGIN {
   puts "Initializing Ruby Program"
}

这将产生以下结果 -

Initializing Ruby Program
This is main Ruby Program

Ruby END 语句

句法

END {
   code
}

声明要在程序结束时调用的代码。

例子

现场演示

#!/usr/bin/ruby

puts "This is main Ruby Program"

END {
   puts "Terminating Ruby Program"
}
BEGIN {
   puts "Initializing Ruby Program"
}

这将产生以下结果 -

Initializing Ruby Program
This is main Ruby Program
Terminating Ruby Program

Ruby评论

注释对 Ruby 解释器隐藏一行、一行的一部分或多行。您可以在行的开头使用井号字符 (#) -

# I am a comment. Just ignore me.

或者，注释可以位于语句或表达式之后的同一行 -

name = "Madisetti" # This is again comment

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

# This is a comment.
# This is a comment, too.
# This is a comment, too.
# I said that already.

这是另一种形式。该块注释通过 =begin/=end 对解释器隐藏了几行 -

=begin
This is a comment.
This is a comment, too.
This is a comment, too.
I said that already.
=end

Ruby - 类和对象

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

• 数据封装
• 数据抽象
• 多态性
• 遗产

这些功能已在“面向对象的 Ruby”一章中讨论。

面向对象的程序涉及类和对象。类是创建各个对象的蓝图。用面向对象的术语来说，我们说你的自行车是自行车类对象的一个​​实例。

以任何车辆为例。它包括车轮、马力和燃油或油箱容量。这些特征构成了 Vehicle 类的数据成员。您可以借助这些特征将一辆车与另一辆车区分开来。

车辆还可以具有某些功能，例如停车、行驶和超速。甚至这些函数也构成了 Vehicle 类的数据成员。因此，您可以将类定义为特征和功能的组合。

车辆类可以定义为 -

Class Vehicle {

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

通过为这些数据成员分配不同的值，您可以形成车辆类的多个实例。例如，一架飞机有三个轮子，马力为1000，燃料为油箱类型，容量为100升。同样，一辆汽车有四个轮子，马力为200，油箱类型为汽油，容量为25升。

在 Ruby 中定义一个类

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

Ruby 中的类始终以关键字class开头，后跟类的名称。该名称应始终以大写字母开头。类Customer可以显示为 -

class Customer
end

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

Ruby 类中的变量

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

• 局部变量- 局部变量是在方法中定义的变量。局部变量在方法外部不可用。您将在后续章节中看到有关方法的更多详细信息。局部变量以小写字母或 _ 开头。

• 实例变量- 实例变量可跨任何特定实例或对象的方法使用。这意味着实例变量会随着对象的不同而变化。实例变量前面有 at 符号 (@)，后面是变量名称。

• 类变量- 类变量可跨不同对象使用。类变量属于类，是类的特征。它们前面是符号@@，后面是变量名称。

• 全局变量- 类变量不可跨类使用。如果您想要跨类使用单个变量，则需要定义一个全局变量。全局变量前面始终带有美元符号 ($)。

例子

使用类变量@@no_of_customers，您可以确定正在创建的对象的数量。这使得能够获得客户数量。

class Customer
   @@no_of_customers = 0
end

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

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

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

以下是创建 Customer 类的两个对象 cust1 和 cust2 的示例 -

cust1 = Customer. new
cust2 = Customer. new

这里，cust1和cust2是两个对象的名称。您可以编写对象名称，后跟等号 (=)，然后再编写类名称。然后是点运算符和关键字new。

创建 Ruby 对象的自定义方法

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

当您计划声明带参数的新方法时，您需要在类创建时声明方法initialize 。

初始化方法是一种特殊类型的方法，当带参数调用类的new方法时就会执行该方法。

这是创建初始化方法的示例 -

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

在此示例中，您将id、name和addr声明为局部变量的初始化方法。这里，def和end用于定义Ruby方法initialize。您将在后续章节中了解有关方法的更多信息。

在初始化方法中，将这些局部变量的值传递给实例变量@cust_id、@cust_name 和@cust_addr。这里局部变量保存与新方法一起传递的值。

现在，您可以按如下方式创建对象 -

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

Ruby 类中的成员函数

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

方法名称始终首选小写字母。您可以使用关键字end来结束 Ruby 中的方法。

下面是定义 Ruby 方法的示例 -

class Sample
   def function
      statement 1
      statement 2
   end
end

这里，语句1和语句2是类Sample内的方法函数体的一部分。这些语句可以是任何有效的 Ruby 语句。例如，我们可以使用put方法来打印Hello Ruby，如下所示 -

class Sample
   def hello
      puts "Hello Ruby!"
   end
end

现在，在下面的示例中，创建 Sample 类的一个对象并调用hello方法并查看结果 -

现场演示

#!/usr/bin/ruby

class Sample
   def hello
      puts "Hello Ruby!"
   end
end

# Now using above class to create objects
object = Sample. new
object.hello

这将产生以下结果 -

Hello Ruby!

简单案例研究

如果您想对类和对象进行更多练习，这里有一个案例研究。

Ruby 类案例研究

Ruby - 变量、常量和文字

变量是内存位置，保存任何程序使用的任何数据。

Ruby 支持五种类型的变量。您在前一章中也已经了解了这些变量的简短描述。本章解释了这五种类型的变量。

Ruby 全局变量

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

对全局变量的赋值会改变全局状态。不建议使用全局变量。他们使程序变得神秘。

这是一个显示全局变量用法的示例。

现场演示

#!/usr/bin/ruby

$global_variable = 10
class Class1
   def print_global
      puts "Global variable in Class1 is #$global_variable"
   end
end
class Class2
   def print_global
      puts "Global variable in Class2 is #$global_variable"
   end
end

class1obj = Class1.new
class1obj.print_global
class2obj = Class2.new
class2obj.print_global

这里$global_variable是一个全局变量。这将产生以下结果 -

注意- 在 Ruby 中，您可以通过在变量或常量之前放置井号 (#) 字符来访问该变量或常量的值。

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

Ruby 实例变量

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

这是一个显示实例变量用法的示例。

现场演示

#!/usr/bin/ruby

class 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"
   end
end

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

# Call Methods
cust1.display_details()
cust2.display_details()

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

Customer id 1
Customer name John
Customer address Wisdom Apartments, Ludhiya
Customer id 2
Customer name Poul
Customer address New Empire road, Khandala

Ruby 类变量

类变量以 @@ 开头，必须先进行初始化，然后才能在方法定义中使用它们。

引用未初始化的类变量会产生错误。类变量在定义类变量的类或模块的后代之间共享。

使用 -w 选项覆盖类变量会产生警告。

这是一个显示类变量用法的示例 -

现场演示

#!/usr/bin/ruby

class 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"
   end
end

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

# Call Methods
cust1.total_no_of_customers()
cust2.total_no_of_customers()

这里@@no_of_customers是一个类变量。这将产生以下结果 -

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

Ruby 局部变量

局部变量以小写字母或 _ 开头。局部变量的范围从类、模块、def 或 do 到相应的末尾，或者从块的左大括号到其右大括号 {}。

当引用未初始化的局部变量时，它将被解释为对没有参数的方法的调用。

对未初始化的局部变量的赋值也可用作变量声明。变量开始存在，直到到达当前作用域的末尾。局部变量的生命周期是在 Ruby 解析程序时确定的。

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

Ruby常量

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

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

现场演示

#!/usr/bin/ruby

class Example
   VAR1 = 100
   VAR2 = 200
   def show
      puts "Value of first Constant is #{VAR1}"
      puts "Value of second Constant is #{VAR2}"
   end
end

# Create Objects
object = Example.new()
object.show

这里VAR1和VAR2是常数。这将产生以下结果 -

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

Ruby 伪变量

它们是特殊变量，具有局部变量的外观，但Behave类似于常量。您不能为这些变量分配任何值。

• self - 当前方法的接收者对象。

• true - 代表 true 的值。

• false - 代表 false 的值。

• nil - 表示未定义的值。

• __FILE__ - 当前源文件的名称。

• __LINE__ - 源文件中的当前行号。

Ruby 基本文字

Ruby 对文字使用的规则简单且直观。本节解释所有基本的 Ruby 文字。

整数

Ruby 支持整数。整数的范围可以是 -2 ³⁰到 2 ^30-1或 -2 ⁶²到 2 ^62-1。此范围内的整数是Fixnum类的对象，此范围之外的整数存储在Bignum类的对象中。

您可以使用可选的前导符号、可选的基数指示符（0 表示八进制、0x 表示十六进制或 0b 表示二进制）来编写整数，后跟相应基数的数字字符串。数字字符串中下划线字符将被忽略。

您还可以获取与 ASCII 字符相对应的整数值，或者通过在其前面添加问号来转义该序列。

例子

123                  # Fixnum decimal
1_234                # Fixnum decimal with underline
-500                 # Negative Fixnum
0377                 # octal
0xff                 # hexadecimal
0b1011               # binary
?a                   # character code for 'a'
?\n                  # code for a newline (0x0a)
12345678901234567890 # Bignum

注意- 类和对象在本教程的单独章节中进行了解释。

浮动数字

Ruby 支持浮点数。它们也是数字，但带有小数。浮点数是Float类的对象，可以是以下任意一种 -

例子

123.4                # floating point value
1.0e6                # scientific notation
4E20                 # dot not required
4e+20                # sign before exponential

字符串文字

Ruby 字符串只是 8 位字节的序列，它们是 String 类的对象。双引号字符串允许替换和反斜杠表示法，但单引号字符串不允许替换，仅允许反斜杠表示法 \\ 和 \'

例子

现场演示

#!/usr/bin/ruby -w

puts 'escape using "\\"';
puts 'That\'s right';

这将产生以下结果 -

escape using "\"
That's right

您可以使用序列#{ expr }将任何 Ruby 表达式的值替换为字符串。这里，expr 可以是任何 ruby​​ 表达式。

现场演示

#!/usr/bin/ruby -w

puts "Multiplication Value : #{24*60*60}";

这将产生以下结果 -

Multiplication Value : 86400

反斜杠符号

以下是 Ruby 支持的反斜杠符号列表 -

有关 Ruby 字符串的更多详细信息，请参阅Ruby 字符串。

Ruby数组

Ruby 数组的文字是通过在方括号之间放置一系列以逗号分隔的对象引用来创建的。后面的逗号将被忽略。

例子

现场演示

#!/usr/bin/ruby

ary = [  "fred", 10, 3.14, "This is a string", "last element", ]
ary.each do |i|
   puts i
end

这将产生以下结果 -

fred
10
3.14
This is a string
last element

有关 Ruby 数组的更多详细信息，请参阅Ruby 数组。

Ruby哈希

字面量 Ruby Hash 是通过在大括号之间放置键/值对列表来创建的，在键和值之间使用逗号或序列 =>。后面的逗号将被忽略。

例子

现场演示

#!/usr/bin/ruby

hsh = colors = { "red" => 0xf00, "green" => 0x0f0, "blue" => 0x00f }
hsh.each do |key, value|
   print key, " is ", value, "\n"
end

这将产生以下结果 -

red is 3840
green is 240
blue is 15

有关 Ruby Hashes 的更多详细信息，请参阅Ruby Hashes。

Ruby山脉

范围表示一个间隔，它是一组具有开始和结束的值。范围可以使用 s..e 和 s...e 文字或使用 Range.new 来构造。

使用 .. 构建的范围从开始到结束（包含在内）。那些使用...创建的不包括最终值。当用作迭代器时，范围返回序列中的每个值。

范围 (1..5) 表示它包括 1, 2, 3, 4, 5 个值，范围 (1...5) 表示它包括 1, 2, 3, 4 个值。

例子

现场演示

#!/usr/bin/ruby

(10..15).each do |n| 
   print n, ' ' 
end

这将产生以下结果 -

10 11 12 13 14 15

有关 Ruby Ranges 的更多详细信息，请参阅Ruby Ranges。

Ruby - 运算符

Ruby 支持一组丰富的运算符，正如您对现代语言所期望的那样。大多数运算符实际上是方法调用。例如，a + b 被解释为 a.+(b)，其中变量a引用的对象中的 + 方法以b作为参数进行调用。

对于每个运算符（+ - * / % ** & | ^ << >> && ||），都有相应形式的缩写赋值运算符（+= -= 等）。

Ruby 算术运算符

假设变量 a 为 10，变量 b 为 20，则 -

Ruby 比较运算符

假设变量 a 为 10，变量 b 为 20，则 -

Ruby 赋值运算符

假设变量 a 为 10，变量 b 为 20，则 -

Ruby 并行赋值

Ruby 还支持变量的并行赋值。这使得可以使用一行 Ruby 代码来初始化多个变量。例如 -

a = 10
b = 20
c = 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定义？运营商

定义？是一个特殊的运算符，它采用方法调用的形式来确定是否定义了传递的表达式。它返回表达式的描述字符串，如果未定义表达式，则返回nil 。

定义有多种用法？操作员

用法1

defined? variable # True if variable is initialized

例如

foo = 42
defined? foo    # => "local-variable"
defined? $_     # => "global-variable"
defined? bar    # => nil (undefined)

用法2

defined? method_call # True if a method is defined

例如

defined? puts        # => "method"
defined? puts(bar)   # => nil (bar is not defined here)
defined? unpack      # => nil (not defined here)

用法3

# True if a method exists that can be called with super user
defined? super

例如

defined? super     # => "super" (if it can be called)
defined? super     # => nil (if it cannot be)

用法4

defined? yield   # True if a code block has been passed

例如

defined? yield    # => "yield" (if there is a block passed)
defined? yield    # => nil (if there is no block)

Ruby点“。” 和双冒号“::”运算符

您可以通过在模块名称前加上模块名称和句点来调用模块方法，并使用模块名称和两个冒号引用常量。

::是一个一元运算符，允许：从类或模块外部的任何位置访问在类或模块内定义的常量、实例方法和类方法。

请记住，在 Ruby 中，类和方法也可以被视为常量。

您只需在:: Const_name 前面加上一个返回适当的类或模块对象的表达式即可。

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

这是两个例子 -

MR_COUNT = 0         # constant defined on main Object class
module Foo
   MR_COUNT = 0
   ::MR_COUNT = 1    # set global count to 1
   MR_COUNT = 2      # set local count to 2
end
puts MR_COUNT        # this is the global constant
puts Foo::MR_COUNT   # this is the local "Foo" constant

第二个例子

CONST = ' out there'
class Inside_one
   CONST = proc {' in there'}
   def where_is_my_CONST
      ::CONST + ' inside one'
   end
end
class Inside_two
   CONST = ' inside two'
   def where_is_my_CONST
      CONST
   end
end
puts Inside_one.new.where_is_my_CONST
puts Inside_two.new.where_is_my_CONST
puts Object::CONST + Inside_two::CONST
puts Inside_two::CONST + CONST
puts Inside_one::CONST
puts Inside_one::CONST.call + Inside_two::CONST

Ruby 运算符优先级

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

注意- 方法列中带有“是”的运算符实际上是方法，因此可能会被覆盖。

Ruby - 评论

注释是 Ruby 代码中的注释行，在运行时会被忽略。单行注释以 # 字符开头，它们从 # 延伸到行尾，如下所示 -

现场演示

#!/usr/bin/ruby -w
# This is a single line comment.

puts "Hello, Ruby!"

执行时，上述程序产生以下结果 -

Hello, Ruby!

Ruby 多行注释

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

现场演示

#!/usr/bin/ruby -w

puts "Hello, Ruby!"

=begin
This is a multiline comment and con spwan as many lines as you
like. But =begin and =end should come in the first line only. 
=end

执行时，上述程序产生以下结果 -

Hello, Ruby!

确保尾随注释距离代码足够远，并且易于区分。如果块中存在多个尾随注释，请将它们对齐。例如 -

@counter      # keeps track times page has been hit
@siteCounter  # keeps track of times all pages have been hit

Ruby - if...else、case、除非

Ruby 提供了现代语言中非常常见的条件结构。在这里，我们将解释 Ruby 中可用的所有条件语句和修饰符。

Ruby if...else 语句

句法

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

if表达式用于条件执行。false和nil值是 false，其他值都是 true。注意 Ruby 使用 elsif，而不是 else if 或 elif。

如果条件为真则执行代码。如果条件不成立，则执行 else 子句中指定的代码。

if 表达式的条件通过保留字then、换行符或分号与代码分隔。

例子

现场演示

#!/usr/bin/ruby

x = 1
if x > 2
   puts "x is greater than 2"
elsif x <= 2 and x!=0
   puts "x is 1"
else
   puts "I can't guess the number"
end

x is 1

Ruby if 修饰符

句法

code if condition

如果条件为真则执行代码。

例子

现场演示

#!/usr/bin/ruby

$debug = 1
print "debug\n" if $debug

这将产生以下结果 -

debug

Ruby except 语句

句法

unless conditional [then]
   code
[else
   code ]
end

如果条件为 false，则执行代码。如果条件为 true，则执行 else 子句中指定的代码。

例子

现场演示

#!/usr/bin/ruby

x = 1 
unless x>=2
   puts "x is less than 2"
 else
   puts "x is greater than 2"
end

这将产生以下结果 -

x is less than 2

Ruby except 修饰符

句法

code unless conditional

如果条件为 false，则执行代码。

例子

现场演示

#!/usr/bin/ruby

$var =  1
print "1 -- Value is set\n" if $var
print "2 -- Value is set\n" unless $var

$var = false
print "3 -- Value is set\n" unless $var

这将产生以下结果 -

1 -- Value is set
3 -- Value is set

Ruby 案例声明

句法

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

使用===运算符比较case指定的表达式和when指定的表达式，并执行匹配的when子句的代码。

When 子句指定的表达式被计算为左操作数。如果没有when 子句匹配，则case执行else子句的代码。

When语句的表达式通过保留字 then、换行符或分号与代码分隔。因此 -

case expr0
when expr1, expr2
   stmt1
when expr3, expr4
   stmt2
else
   stmt3
end

基本上类似于以下内容 -

_tmp = expr0
if expr1 === _tmp || expr2 === _tmp
   stmt1
elsif expr3 === _tmp || expr4 === _tmp
   stmt2
else
   stmt3
end

例子

现场演示

#!/usr/bin/ruby

$age =  5
case $age
when 0 .. 2
   puts "baby"
when 3 .. 6
   puts "little child"
when 7 .. 12
   puts "child"
when 13 .. 18
   puts "youth"
else
   puts "adult"
end

这将产生以下结果 -

little child

Ruby - 循环

Ruby 中的循环用于执行同一代码块指定的次数。本章详细介绍了 Ruby 支持的所有循环语句。

Ruby while 语句

句法

while conditional [do]
   code
end

当条件为真时执行代码。while循环的条件通过保留字 do、换行符、反斜杠 \ 或分号 ; 与代码分隔。

例子

现场演示

#!/usr/bin/ruby

$i = 0
$num = 5

while $i < $num  do
   puts("Inside the loop i = #$i" )
   $i +=1
end

这将产生以下结果 -

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

Ruby while 修饰符

句法

code while condition

OR

begin 
  code 
end while conditional

当条件为真时执行代码。

如果while修饰符跟在begin语句后面且没有救援或 Ensure 子句，则在评估条件之前执行一次代码。

例子

现场演示

#!/usr/bin/ruby

$i = 0
$num = 5
begin
   puts("Inside the loop i = #$i" )
   $i +=1
end while $i < $num

这将产生以下结果 -

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

Ruby 直到声明

until conditional [do]
   code
end

当条件为 false时执行代码。Until语句的条件通过保留字do、换行符或分号与代码分隔。

例子

现场演示

#!/usr/bin/ruby

$i = 0
$num = 5

until $i > $num  do
   puts("Inside the loop i = #$i" )
   $i +=1;
end

这将产生以下结果 -

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

Ruby 直到修饰符

句法

code until conditional

OR

begin
   code
end until conditional

当条件为 false时执行代码。

如果在begin语句后面有一个until修饰符，但没有rescue或ensure 子句，则在计算条件之前会执行一次代码。

例子

现场演示

#!/usr/bin/ruby

$i = 0
$num = 5
begin
   puts("Inside the loop i = #$i" )
   $i +=1;
end until $i > $num

这将产生以下结果 -

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

Ruby for 语句

句法

for variable [, variable ...] in expression [do]
   code
end

对expression中的每个元素执行一次代码。

例子

现场演示

#!/usr/bin/ruby

for i in 0..5
   puts "Value of local variable is #{i}"
end

在这里，我们定义了范围 0..5。for i in 0..5 的语句将允许i取 0 到 5 范围内的值（包括 5）。这将产生以下结果 -

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

for ...in循环几乎完全等同于以下内容 -

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

除了for循环不会为局部变量创建新的作用域之外。for循环的表达式通过保留字 do、换行符或分号与代码分隔。

例子

现场演示

#!/usr/bin/ruby

(0..5).each do |i|
   puts "Value of local variable is #{i}"
end

这将产生以下结果 -

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

Ruby 中断语句

句法

break

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

例子

现场演示

#!/usr/bin/ruby

for i in 0..5
   if i > 2 then
      break
   end
   puts "Value of local variable is #{i}"
end

这将产生以下结果 -

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2

Ruby 下一个声明

句法

next

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

例子

现场演示

#!/usr/bin/ruby

for i in 0..5
   if i < 2 then
      next
   end
   puts "Value of local variable is #{i}"
end

这将产生以下结果 -

Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

Ruby 重做语句

句法

redo

重新启动最内部循环的迭代，而不检查循环条件。如果在块内调用，则重新启动yield或call 。

例子

#!/usr/bin/ruby

for i in 0..5
   if i < 2 then
      puts "Value of local variable is #{i}"
      redo
   end
end

这将产生以下结果并将进入无限循环 -

Value of local variable is 0
Value of local variable is 0
............................

Ruby 重试语句

句法

retry

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

begin
   do_something # exception raised
rescue
   # handles error
   retry  # restart from beginning
end

如果 retry 出现在迭代器、块或for表达式的主体中，则重新启动调用