Ruby 数据类型

本章我们讨论数据类型，各种计算机程序（包括电子表格，文本编辑器，计算器和聊天客户端）都可以处理数据。 用于各种数据类型的工具是现代计算机语言的基本组成部分。 数据类型是一组值，以及对这些值的允许操作。

Ruby 数据类型列表

Ruby 有几种数据类型。 所有数据类型均基于类。 以下是 Ruby 识别的数据类型：

• 布尔值
• 符号
• 号码
• 弦乐
• 数组
• 散列

在以下示例中，我们具有所有重要的 Ruby 数据类型。

#!/usr/bin/ruby

h = { :name => "Jane", :age => 17 }

p true.class, false.class
p "Ruby".class
p 1.class
p 4.5.class
p 3_463_456_457.class
p :age.class
p [1, 2, 3].class
p h.class

我们打印他们的班级名称。 一个类是从每个对象创建的模板。

p true.class, false.class

布尔值由 true 和 false 对象表示。

p "Ruby".class

这是字符串。

p 1.class
p 4.5.class
p 3_463_456_457.class

这些是数字。

p :age.class

这是一个符号，一种特定于 Ruby 的数据类型。

p [1, 2, 3].class
p h.class

这是两个容器，数组和哈希。

$ ./types.rb
TrueClass
FalseClass
String
Fixnum
Float
Bignum
Symbol
Array
Hash

该程序列出了属于 Ruby 数据类型的类。

Ruby 布尔值

我们的世界建立了双重性。 有天与地，水与火，井与章，男人与女人，爱与恨。 这就是我们生存的“布尔”性质。 在 Ruby 中，布尔数据类型可以具有两个值之一：true 或 false。 布尔是一种基本的数据类型：在计算机程序中非常常见的一种。

快乐的父母正在等待孩子的出生。 他们为两种可能性都选择了名称。 如果要成为男孩，他们选择了约翰。 如果要成为女孩，他们会选择维多利亚。

#!/usr/bin/ruby

# kid.rb

bool = [true, false]

male = bool[rand(2)]

if male
    puts "We will use name John"
else 
    puts "We will use name Victoria"
end

该程序使用随机数生成器来模拟我们的情况。

bool = [true, false]

我们有一个bool变量。 它是两个布尔值的数组。 用方括号创建一个数组。

male = bool[rand(2)]

我们使用rand()方法创建一个随机数。 该方法返回 0 或 1。返回的数字是 bool 数组的索引。

if male
    puts "We will use name John"
else 
    puts "We will use name Victoria"
end

根据公变量，我们打印一条消息。 如果将 male 变量设置为 true，则选择名称 John。 否则，我们选择名称 Victoria。 诸如 if / else 语句之类的控制结构可使用布尔值。

$ ./kid.rb 
We will use name Victoria
$ ./kid.rb 
We will use name Victoria
$ ./kid.rb 
We will use name John
$ ./kid.rb 
We will use name John
$ ./kid.rb 
We will use name John

多次运行该程序。

Ruby 符号

符号用于表示其他对象。 使用符号代替字符串可以节省一些资源。 符号是Symbol类的实例对象。 通过在标识符（如:name）之前使用冒号来生成符号。 几个对象也具有to_sym方法。 这些方法将那些对象转换为符号。

Ruby 符号不能在运行时更改。 Ruby 符号通常用作哈希键，因为我们不需要键的字符串对象的全部功能。

#!/usr/bin/ruby

p :name
p :name.class
p :name.methods.size
p "Jane".methods.size

p :name.object_id
p :name.object_id
p "name".object_id
p "name".object_id

在第一个示例中，我们展示了一些使用 Ruby 符号的基本操作。

p :name
p :name.class

我们将符号及其类输出到控制台。 符号的类别为Symbol。

p :name.methods.size
p "Jane".methods.size

我们比较了与符号和字符串实例关联的方法的数量。 字符串的方法数量是符号的两倍以上。

p :name.object_id
p :name.object_id
p "name".object_id
p "name".object_id

相同的符号具有相同的 ID。 相同的字符串具有不同的 ID。

$ ./symbols.rb
:name
Symbol
79
162
10328
10328
77344750
77344730

样本输出。

符号可以用作标志。 在这种情况下也可以使用常量。 在 C / C++ 中，我们将使用枚举。

#!/usr/bin/ruby

light = :on

if light == :on
    puts "The light is on"
else
    puts "The light is off"
end

light = :off

if light == :on
    puts "The light is on"
else
    puts "The light is off"
end

指示灯点亮或熄灭。 对于这两种状态，我们都可以定义符号。

light = :on

灯亮。

if light == :on
    puts "The light is on"
else
    puts "The light is off"
end

程序的逻辑取决于light变量的状态。

符号通常用作哈希容器中的键。 它们比字符串更有效。

#!/usr/bin/ruby

domains = {:sk => "Slovakia", :no => "Norway", :hu => "Hungary"}

puts domains[:sk]
puts domains[:no]
puts domains[:hu]

在脚本中，我们有一个域哈希。 哈希中的键是符号。

puts domains[:sk]
puts domains[:no]
puts domains[:hu]

键用于访问哈希值。 在这里，我们打印哈希的三个值。

$ ./symbols3.rb
Slovakia
Norway
Hungary

示例的输出。

Ruby 解释器在内部将一些引用存储为符号。

#!/usr/bin/ruby

class Being

    def initialize
        @is = true
    end

    def say
        "I am being"
    end
end

b = Being.new

p b.method :say
p b.instance_variable_get :@is

定义了Being类。 该类具有一个自定义实例变量@is和say方法。 这两个实体由 Ruby 使用符号存储。

p b.method :say

method方法在b对象中查找具有给定名称的接收器方法。 我们在寻找:say符号。

p b.instance_variable_get :@is

我们使用instance_variable_get检查@is是否是b对象的实例变量。 在内部，变量存储为:@is符号。

$ ./symbols4.rb 
#<Method: Being#say>
true

生成的输出。

所有符号都存储在符号表中。 在下一个示例中，我们看一下表格。 Symbol类的all_symbols方法返回表中所有符号的数组。

#!/usr/bin/ruby

def info
  "info method"
end

@v = "Ruby"
@@n = "16"

p Symbol.all_symbols.include? :info
p Symbol.all_symbols.include? :@v
p Symbol.all_symbols.include? :@@n

在 Ruby 脚本中创建方法，实例变量和类变量。 我们检查这些实体是否存储在符号表中。

p Symbol.all_symbols.include? :info

我们检查:info符号是否在符号表中。 该行返回 true。

$ ./symbols5.rb
true
true
true

这三个符号都存在于 Ruby 符号表中。

Ruby 整数

整数是实数的子集。 它们写时没有小数或小数部分。 整数属于集合 Z = {…，-2，-1，0，1，2，……}此集合是无限的。

在计算机语言中，整数是原始数据类型。 实际上，由于计算机的容量有限，因此计算机只能使用整数值的子集。 整数用于计算离散实体。 我们可以有 3、4 或 6 个人，但不能有 3.33 个人。 我们可以有 3.33 公斤。

整数是 Ruby 中Fixnum或Bignum类的实例对象。 与 Java 或 C 这样的语言不同，Ruby 中的整数是对象。 这两个类别的大小不同。 Fixnum数字是不超过一定限制的整数。 该限制取决于机器。 Bignum值保存Fixnum范围之外的整数。 如果对Fixnum的任何操作超出其范围，则该值将自动转换为Bignum。 程序员通常不需要关心整数的类类型。

#!/usr/bin/ruby

p -2
p 121
p 123265
p -34253464356
p 34867367893463476

p 1.class
p 23453246.class
p 234532423563456346.class
p 2345324235632363463456456346.class

p 5 / 2
p 5.div 2

在此示例中，我们处理整数。

p -2
p 121
p 123265
p -34253464356
p 34867367893463476

这些是各种大小的正整数和负整数。

p 1.class
p 23453246.class
p 234532423563456346.class
p 2345324235632363463456456346.class

我们打印这些整数的类。 前两个整数是Fixnum类的实例。 另外两个是Bignum类的实例。

p 5 / 2
p 5.div 2

这两行显示整数除法。 当我们使用整数除法运算符/方法除以两个整数时，结果也是一个整数。

$ ./integers.rb
-2
121
123265
-34253464356
34867367893463476
Fixnum
Fixnum
Bignum
Bignum
2
2

示例的输出。

可以在 Ruby 中使用不同的表示法指定整数：十进制，十六进制，八进制和二进制。 据我们所知，通常使用十进制数。 十六进制数字以0x字符开头，八进制以0字符开头，二进制以0b字符开头。

#!/usr/bin/ruby

puts 122
puts 0x7a
puts 0172
puts 0b1111010

在代码示例中，我们以所有这些符号打印十进制 122。

$ ./inotations.rb
122
122
122
122

示例的输出。

如果我们使用整数，那么我们将处理离散实体。 我们将使用整数来计算苹果。

#!/usr/bin/ruby

baskets = 16
apples_in_basket = 24

total = baskets * apples_in_basket

puts "There are total of #{total} apples"

在我们的程序中，我们计算了苹果的总量。 我们使用整数。

$ ./apples.rb
There are total of 384 apples

程序的输出。

大数字很难阅读。 如果我们有一个像 245342395423452 这样的数字，我们会发现很难快速阅读。 在计算机外部，大数字之间用空格或逗号分隔。 为了提高可读性，Ruby 允许整数包含下划线。 Ruby 解释器将忽略整数中的下划线。

#!/usr/bin/ruby

p 23482345629
p 23_482_345_629

p 23482345629 == 23_482_345_629

该示例演示了下划线的用法。

p 23482345629 == 23_482_345_629

此行表明两个数字相等。 它打印真实。

$ ./underscore.rb
23482345629
23482345629
true

示例输出。

Ruby 浮点数

浮点数表示计算中的实数。 实数测量连续的量，例如重量，高度或速度。 在 Ruby 中，十进制数字是Float或BigDecimal类的对象。 BigDecimal类是 Ruby 的核心类，是 Ruby 标准库的一部分。 另外，我们也可以使用Rational对象。

我们需要了解十进制数字并不精确。 Ruby 的官方文档明确指出，浮点对象表示不精确的实数。

#!/usr/bin/ruby

p 15.4
p 0.3455
p -343.4563

p 12.5.class
p -12.5.class
p (5.0 / 2).class

p 5.fdiv 2
p 12.to_f

在上面的程序中，我们使用浮点值。

p 15.4
p 0.3455
p -343.4563

在这里，我们打印三个十进制值。 小数点有小数点字符。

p 12.5.class
p -12.5.class
p (5.0 / 2).class

上面的代码行显示了数字的类型。 全部都是花车。 至少在一个Float上应用整数除法也会产生Float。

p 5.fdiv 2
p 12.to_f

在这里，我们通过使用浮点fdiv除法和转换to_f方法来创建浮点值。

$ ./decimals.rb
15.4
0.3455
-343.4563
Float
Float
Float
2.5
12.0

输出。

默认情况下，显示的十进制数字在小数点后最多 16 个数字。 我们可以使用sprintf或printf方法控制浮点值的格式。

#!/usr/bin/ruby

p 1/3.0
p 1.fdiv 2

puts sprintf "%.4f" % (1/3.0)
puts sprintf "%.7f" % (5/3.0)

格式化十进制数字。

p 1/3.0
p 13.fdiv 4
p 1.fdiv 2

第一行打印一个小数点后的 16 位。 第二行在该点之后打印两个数字，第三行打印。

puts sprintf "%.4f" % (1/3.0)
puts sprintf "%.7f" % (5/3.0)

在这里，我们使用sprintf方法控制小数点后的值数量。 sprintf方法的格式说明符存在精度。 它是%字符后的数字。 f是一个转换说明符，表示我们正在处理浮点值。

$ ./formatfloat.rb
0.3333333333333333
3.25
0.5
0.3333
1.6666667

Output.

Ruby 支持对浮点值使用科学计数法。 也称为指数表示法，它是一种写数字太大或太小而不能方便地用标准十进制表示法写的方式。

#!/usr/bin/ruby

p 1.2e-3
p 0.0012

p 1.5E-4
p 0.00015

该示例显示了两个用科学计数法表示的十进制数字。

$ ./scientific.rb
0.0012
0.0012
0.00015
0.00015

这是上面程序的输出。

如前所述，浮点值有些不准确。 对于许多计算，普通的浮点数足够精确： 如果我们的体重是 60kg 或 60.000023kg，那不是很重要。 对于其他计算，包括许多科学和工程应用，精度至关重要。

Ruby 在标准库中有一个BigDecimal。 此类为非常大或非常准确的浮点数提供任意精度。

#!/usr/bin/ruby

require 'bigdecimal'

sum = 0

1000.times do
    sum = sum + 0.0001
end

p sum

sum = BigDecimal.new("0")

1000.times do
    sum = sum + BigDecimal.new("0.0001")
end

puts sum.to_s('F')
puts sum.to_s('E')

在这个简单的示例中，我们比较了Float与BigDecimal的精度。

require 'bigdecimal'

必须导入BigDecimal类。

sum = 0

1000.times do
    sum = sum + 0.0001
end

p sum

我们形成一个循环，在该循环中，我们将一个小的 floatig 点值添加到 sum 变量中。 最后，将有一个小的误差。

sum = BigDecimal.new("0")

1000.times do
    sum = sum + BigDecimal.new("0.0001")
end

我们使用BigDecimal值进行相同的循环。

puts sum.to_s('F')
puts sum.to_s('E')

总和以浮点数和工程符号形式打印。

$ ./bigdecimal.rb
0.10000000000000184
0.1
0.1E0

输出显示，使用BigDecimal进行的计算比使用Floats进行的计算更为精确。

假设一个短跑运动员跑了 1 个小时，跑了 9.87 秒。 他的公里/小时速度是多少？

#!/usr/bin/ruby

distance = 0.1
time = 9.87 / 3600

speed = distance / time

puts "The average speed of a sprinter is #{speed} km/h"

在此示例中，必须使用浮点值。

distance = 0.1

100m 是 0.1 公里。

time = 9.87 / 3600

9.87s 是 9.87 / 60 * 60 h

speed = distance / time

为了获得速度，我们将距离除以时间。

$ ./speed.rb
The average speed of a sprinter is 36.4741641337386 km/h

这是speed.rb脚本的输出。

Ruby 有理数

Ruby 支持有理数。 有理数是精确数。 使用有理数可以避免舍入误差。 在 Ruby 中，有理数是Rational类的对象。 我们可以使用特殊的to_r方法从某些对象创建有理数。

有理数是可以表示为两个整数 a / b 的分数的任何数字，其中 b！= 0。 由于 b 可以等于 1，所以每个整数都是有理数。

#!/usr/bin/ruby

puts 2.to_r
puts "23".to_r
puts 2.6.to_r

p Rational 0
p Rational 1/5.0
p Rational 0.5

此示例显示了一些有理数。

puts 2.to_r

在这里，我们使用to_r方法将 2 整数转换为 2/1 有理数。

p Rational 0.5

我们使用Rational类创建一个有理数。

$ ./rational.rb
2/1
23/1
5854679515581645/2251799813685248
(0/1)
(3602879701896397/18014398509481984)
(1/2)

Ruby nil值

Ruby 具有特殊值nil。 这是没有价值的。 nil是NilClass的单例对象。 只有一个nil； 我们不能再拥有更多了。

#!/usr/bin/ruby

puts nil
p nil

p val

p [1, 2, 3][4] 

pval1 == $val2

nil值的示例。

puts nil
p nil

我们将nil值打印到控制台。 puts方法打印一个空字符串； p方法显示’nil’字符串。

p $val

当我们引用一个未设置的全局变量时，我们得到nil值。

p [1, 2, 3][3] 

在此代码行中，我们引用三元素数组的第四个元素。 我们得到nil。 Ruby 中的许多方法都会为无效值返回nil。

p val1 ==val2

该行返回 true。 这是由于nil值是NilClass的单例对象这一事实的结果。

$ ./nilvalue.rb

nil
nil
nil
true

Ruby 字符串

字符串是表示计算机程序中文本数据的数据类型。 Ruby 字符串是 unicode 字符的序列。 字符串是String的实例。 字符串文字是用双或单引号括起来的字符。

字符串是非常重要的数据类型。 它值得一章。 这里我们仅举一个小例子。

#!/usr/bin/ruby

p "Ruby"
p 'Python'

p "Ruby".size
p "Ruby".upcase

p 23.to_s

在此程序中，我们使用 Ruby 字符串。 我们使用p方法进行打印，因为我们在输出中看到了数据类型。

p "Ruby"
p 'Python'

我们在终端上打印两个字符串文字。 第一个文字用双引号括起来，第二个文字用单引号括起来。

p "Ruby".size
p "Ruby".upcase

这两行调用两个字符串方法。 size方法返回字符串的大小：在本例中为 4 个字符。 upcase以大写字母返回字符串。

p 23.to_s

to_s方法将整数转换为字符串。

$ ./strings.rb
"Ruby"
"Python"
4
"RUBY"
"23"

在输出中，我们看到用引号引起来的字符串。 这是使用p方法的结果。 print和puts方法不这样做。

Ruby 数组和哈希

数组和哈希是对象的集合。 他们将对象分组到一个位置。

数组是对象的有序集合。 哈希是键值对的集合。 我们将只有一章介绍数组和哈希。 以下示例仅简要介绍了这两个容器。

#!/usr/bin/ruby

nums = [1, 2, 3, 4]

puts "There are #{nums.size} items in the array"

nums.each do |num|
    puts num
end

domains = { :de => "Germany", :sk => "Slovakia",
            :us => "United States", :no => "Norway" }

puts domains.keys
puts domains.values

这是一个有关 Ruby 数组和哈希的快速示例。

nums = [1, 2, 3, 4]

puts "There are #{nums.size} items in the array"

nums.each do |num|
    puts num
end

这些行创建一个包含 4 个项目的数组。 在第二行中，我们计算数组的项并将其合并到消息中。 稍后，我们使用each方法遍历数组，并将每个元素打印到控制台。

domains = { :de => "Germany", :sk => "Slovakia",
            :us => "United States", :no => "Norway" }

puts domains.keys
puts domains.values

在这里，我们创建一个 Ruby 哈希。 然后我们打印其键和值。

$ ./arrayshashes.rb
There are 4 items in the array
1
2
3
4
de
sk
us
no
Germany
Slovakia
United States
Norway

Ruby 转换

我们经常一次处理多种数据类型。 将一种数据类型转换为另一种数据类型是编程中的常见工作。 类型转换或类型转换是指将一种数据类型的实体更改为另一种。 有两种转换类型：隐式转换和显式转换。 隐式类型转换，也称为强制转换，是编译器自动进行的类型转换。 Ruby 只有显式转换。

Ruby 具有内置的转换方法，例如to_i，to_s或to_f。 Kernel模块具有一些进行转换的公共方法，例如Integer，String或Float。 这些方法不应与 Ruby 类混淆。

#!/usr/bin/ruby

p Array(1..6)
p Complex 6
p Float 12
p Integer "34"
p Rational 6
p String 22

这里我们展示Kernel转换方法。

$ ./convertmethods.rb
[1, 2, 3, 4, 5, 6]
(6+0i)
12.0
34
(6/1)
"22"

#!/usr/bin/ruby

p "12".to_i
p 12.5.to_i
p nil.to_i

p 12.to_f
p "11".to_f
p nil.to_f

在上面的示例中，我们显示了一些数值转换。 某些 Ruby 对象具有to_i和to_f方法，分别将对象转换为整数和浮点数。

p "12".to_i
p 12.5.to_i
p nil.to_i

在此代码中，我们将字符串，十进制和nil转换为整数类型。

p 12.to_f
p "11".to_f
p nil.to_f      

这三行将整数，字符串和nil转换为十进制数据类型的对象。

$ ./conversions.rb
12
12
0
12.0
11.0
0.0

第二个示例显示了一些字符串转换。

#!/usr/bin/ruby

p "12".to_i
p "13".to_f
p "12".to_r
p "13".to_c

p "Jane".to_sym

v = "Ruby Python Tcl PHP Perl".split
p v.class

在上面的示例中，我们将字符串转换为不同数据类型的对象。

p "12".to_i
p "13".to_f
p "12".to_r
p "13".to_c

在这里，字符串将转换为整数，十进制，有理数和复数。

p "Jane".to_sym

字符串成为符号。

v = "Ruby Python Tcl PHP Perl".split
p v.class

在这里，我们使用String类的split方法将字符串转换为数组。

$ ./stringconv.rb
12
13.0
(12/1)
(13+0i)
:Jane
Array

这就是我们得到的。

下一个小示例显示了数组哈希转换。

#!/usr/bin/ruby

h = {:de => "Germany", :sk => "Slovakia"}
p h.to_a

a = [:de, "Germany", :sk, "Slovakia", 
     :hu, "Hungary", :no, "Norway"]
p Hash[*a]

在示例代码中，我们创建了一个哈希并将其隐秘到数组中。 然后，我们创建一个数组并将其转换为哈希。

h = {:de => "Germany", :sk => "Slovakia"}
p h.to_a

使用to_a方法创建哈希并将其转换为数组。

a = [:de, "Germany", :sk, "Slovakia", 
     :hu, "Hungary", :no, "Norway"]
p Hash[*a]

创建一个数组并将其转换为哈希。 在此上下文中，星号是 splat 运算符。 这是从 Perl 提取的 Ruby 惯用语之一。 它将数组拆分为几个变量。

$ ./h2a.rb
[[:de, "Germany"], [:sk, "Slovakia"]]
{:de=>"Germany", :sk=>"Slovakia", :hu=>"Hungary", :no=>"Norway"}