Ruby数据类型、类和对象、类案例

Ruby 数据类型

Ruby支持的数据类型包括基本的Number、String、Ranges、Symbols，以及true、false和nil这几个特殊值，同时还有两种重要的数据结构——Array和Hash。

数值类型(Number)

整型(Integer)

整型分两种，如果在31位以内（四字节），那为Fixnum实例。如果超过，即为Bignum实例。
可以在整数前使用一个可选的前导符号，一个可选的基础指标（0 对应 octal，0x 对应 hex，0b 对应 binary），后跟一串数字。下划线字符在数字字符串中被忽略。
可以获取一个 ASCII 字符或一个用问号标记的转义序列的整数值。

123                  # Fixnum 十进制
1_234                # Fixnum 带有下划线的十进制
-500                 # 负的 Fixnum
0377                 # 八进制
0xff                 # 十六进制
0b1011               # 二进制
"a".ord              # "a" 的字符编码
?\n                  # 换行符（0x0a）的编码
12345678901234567890 # 大数
 
#整型 Integer 以下是一些整型字面量 
#字面量（literal）：代码中能见到的值，数值，bool值，字符串等都叫字面量 
#如以下的0,1_000_000,0xa等 
a1=0 
 
#带千分符的整型 
a2=1_000_000 
 
#其它进制的表示 
a3=0xa 
puts a1,a2 
puts a3 
 
#puts print 都是向控制台打印字符，其中puts带回车换行符 
=begin 
这是注释，称作：嵌入式文档注释 
类似C#中的/**/ 
=end

浮点型

Ruby 支持浮点数。它们是带有小数的数字。浮点数是类 Float 的对象，且可以是下列中任意一个。
实例

123.4                # 浮点值
1.0e6                # 科学记数法
4E20                 # 不是必需的
4e+20                # 指数前的符号
 
#浮点型 
f1=0.0 
f2=2.1 
f3=1000000.1 
puts f3

算术操作
加减乘除操作符：+-*/；指数操作符为**
指数不必是整数，例如

#指数算术 
puts 2**(1/4)#1与4的商为0，然后2的0次方为1 
puts 16**(1/4.0)#1与4.0的商为0.25（四分之一），然后开四次方根

字符串类型

Ruby 字符串简单地说是一个 8 位字节序列，它们是类 String 的对象。
双引号标记的字符串允许替换和使用反斜线符号
单引号标记的字符串不允许替换，且只允许使用 \ 和 ’ 两个反斜线符号。

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

这将产生以下结果：

escape using "\"
That's right

您可以使用序列 #{ expr }替换任意 Ruby 表达式的值为一个字符串。在这里，expr可以是任意的 Ruby 表达式。
实例

#!/usr/bin/ruby -w
puts "相乘 : #{24*60*60}";

这将产生以下结果：

相乘 : 86400

实例

#!/usr/bin/ruby -w
name="Ruby" 
puts name 
puts "#{name+",ok"}"

输出结果为：

Ruby
Ruby,ok

反斜线符号

符号	表示的字符
\n	换行符 (0x0a)
\r	回车符 (0x0d)
\f	换页符 (0x0c)
\b	退格键 (0x08)
\a	报警符 Bell (0x07)
\e	转义符 (0x1b)
\s	空格符 (0x20)
\nnn	八进制表示法 (n 是 0-7)
\xnn	十六进制表示法 (n 是 0-9、a-f 或 A-F)
\cx, \C-x	Control-x
\M-x	Meta-x (c
\M-\C-x	Meta-Control-x
\x	字符 x

数组

数组字面量通过[]中以逗号分隔定义，且支持range定义。

• （1）数组通过[]索引访问
• （2）通过赋值操作插入、删除、替换元素
• （3）通过+，－号进行合并和删除元素，且集合做为新集合出现
• （4）通过<<号向原数据追加元素
• （5）通过*号重复数组元素
• （6）通过｜和&符号做并集和交集操作（注意顺序）

#!/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 哈希是在大括号内放置一系列键/值对，键和值之间使用逗号和序列 => 分隔。尾部的逗号会被忽略。

实例

#!/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

范围类型

一个范围表示一个区间。
范围是通过设置一个开始值和一个结束值来表示。范围可使用 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 类和对象

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 Customer
end

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

Ruby 类中的变量

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

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

class Customer
   @@no_of_customers=0
end

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

对象是类的实例。

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

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

cust1 = Customer. new
cust2 = 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
   end
end

在本实例中，您可以声明带有 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
   end
end

在这里，statement 1 和 statement 2 是类 Sample 内的方法 function 的主体的组成部分。这些语句可以是任何有效的 Ruby 语句。例如，我们可以使用方法 puts 来输出 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
 
# 使用上面的类来创建对象
object = Sample. new
object.hello

这将会产生下面的结果：

Hello Ruby!

Ruby 类案例

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

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

#!/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

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/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
 
# 创建对象
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 1
Customer name John
Customer address Wisdom Apartments, Ludhiya
Total number of customers: 1
Customer id 2
Customer name Poul
Customer address New Empire road, Khandala
Total number of customers: 2