# Ruby 数据类型

> 原文： [https://zetcode.com/lang/rubytutorial/datatypes/](https://zetcode.com/lang/rubytutorial/datatypes/)

在 Ruby 教程的这一部分中，我们将讨论数据类型。

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

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

```

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

```ruby
p true.class, false.class

```

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

```ruby
p "Ruby".class

```

这是字符串。

```ruby
p 1.class
p 4.5.class
p 3_463_456_457.class

```

这些是数字。

```ruby
p :age.class

```

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

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

```

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

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

```

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

## Ruby 布尔值

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

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

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

```

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

```ruby
bool = [true, false]

```

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

```ruby
male = bool[rand(2)]

```

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

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

```

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

```ruby
$ ./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 符号通常用作哈希键，因为我们不需要键的字符串对象的全部功能。

```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 符号的基本操作。

```ruby
p :name
p :name.class

```

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

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

```

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

```ruby
p :name.object_id
p :name.object_id
p "name".object_id
p "name".object_id

```

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

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

```

样本输出。

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

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

```

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

```ruby
light = :on

```

灯亮。

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

```

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

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

```ruby
#!/usr/bin/ruby

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

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

```

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

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

```

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

```ruby
$ ./symbols3.rb
Slovakia
Norway
Hungary

```

示例的输出。

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

```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 使用符号存储。

```ruby
p b.method :say

```

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

```ruby
p b.instance_variable_get :@is

```

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

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

```

生成的输出。

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

```ruby
#!/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 脚本中创建方法，实例变量和类变量。 我们检查这些实体是否存储在符号表中。

```ruby
p Symbol.all_symbols.include? :info

```

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

```ruby
$ ./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`。 程序员通常不需要关心整数的类类型。

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

```

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

```ruby
p -2
p 121
p 123265
p -34253464356
p 34867367893463476

```

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

```ruby
p 1.class
p 23453246.class
p 234532423563456346.class
p 2345324235632363463456456346.class

```

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

```ruby
p 5 / 2
p 5.div 2

```

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

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

```

示例的输出。

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

```ruby
#!/usr/bin/ruby

puts 122
puts 0x7a
puts 0172
puts 0b1111010

```

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

```ruby
$ ./inotations.rb
122
122
122
122

```

示例的输出。

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

```ruby
#!/usr/bin/ruby

baskets = 16
apples_in_basket = 24

total = baskets * apples_in_basket

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

```

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

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

```

程序的输出。

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

```ruby
#!/usr/bin/ruby

p 23482345629
p 23_482_345_629

p 23482345629 == 23_482_345_629

```

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

```ruby
p 23482345629 == 23_482_345_629

```

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

```ruby
$ ./underscore.rb
23482345629
23482345629
true

```

示例输出。

## Ruby 浮点数

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

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

```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

```

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

```ruby
p 15.4
p 0.3455
p -343.4563

```

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

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

```

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

```ruby
p 5.fdiv 2
p 12.to_f

```

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

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

```

输出。

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

```ruby
#!/usr/bin/ruby

p 1/3.0
p 1.fdiv 2

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

```

格式化十进制数字。

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

```

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

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

```

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

```ruby
$ ./formatfloat.rb
0.3333333333333333
3.25
0.5
0.3333
1.6666667

```

Output.

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

```ruby
#!/usr/bin/ruby

p 1.2e-3
p 0.0012

p 1.5E-4
p 0.00015

```

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

```ruby
$ ./scientific.rb
0.0012
0.0012
0.00015
0.00015

```

这是上面程序的输出。

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

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

```ruby
#!/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`的精度。

```ruby
require 'bigdecimal'

```

必须导入`BigDecimal`类。

```ruby
sum = 0

1000.times do
    sum = sum + 0.0001
end

p sum

```

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

```ruby
sum = BigDecimal.new("0")

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

```

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

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

```

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

```ruby
$ ./bigdecimal.rb
0.10000000000000184
0.1
0.1E0

```

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

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

```ruby
#!/usr/bin/ruby

distance = 0.1
time = 9.87 / 3600

speed = distance / time

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

```

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

```ruby
distance = 0.1

```

100m 是 0.1 公里。

```ruby
time = 9.87 / 3600

```

9.87s 是`9.87 / 60 * 60 h`

```ruby
speed = distance / time

```

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

```ruby
$ ./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，所以每个整数都是有理数。

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

```

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

```ruby
puts 2.to_r

```

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

```ruby
p Rational 0.5

```

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

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

```

Output of the example.

## Ruby `nil`值

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

```ruby
#!/usr/bin/ruby

puts nil
p nil

p $val

p [1, 2, 3][4] 

p $val1 == $val2

```

`nil`值的示例。

```ruby
puts nil
p nil

```

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

```ruby
p $val

```

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

```ruby
p [1, 2, 3][3] 

```

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

```ruby
p $val1 == $val2

```

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

```ruby
$ ./nilvalue.rb

nil
nil
nil
true

```

Output.

## Ruby 字符串

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

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

```ruby
#!/usr/bin/ruby

p "Ruby"
p 'Python'

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

p 23.to_s

```

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

```ruby
p "Ruby"
p 'Python'

```

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

```ruby
p "Ruby".size
p "Ruby".upcase

```

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

```ruby
p 23.to_s

```

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

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

```

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

## Ruby 数组和哈希

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

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

```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 数组和哈希的快速示例。

```ruby
nums = [1, 2, 3, 4]

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

nums.each do |num|
    puts num
end

```

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

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

puts domains.keys
puts domains.values

```

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

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

```

Example output.

## Ruby 转换

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

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

```ruby
#!/usr/bin/ruby

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

```

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

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

```

Output of the example.

```ruby
#!/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`方法，分别将对象转换为整数和浮点数。

```ruby
p "12".to_i
p 12.5.to_i
p nil.to_i

```

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

```ruby
p 12.to_f
p "11".to_f
p nil.to_f      

```

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

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

```

Example output.

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

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

```

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

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

```

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

```ruby
p "Jane".to_sym

```

字符串成为符号。

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

```

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

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

```

这就是我们得到的。

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

```ruby
#!/usr/bin/ruby

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

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

```

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

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

```

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

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

```

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

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

```

Output of the example.

在 Ruby 教程的这一部分中，我们介绍了数据类型及其转换。