Ruby 数据类型概述

Preslav Dobrev2022-10-24 · 6 min read

Ruby 是一种著名的编程语言。它旨在提高简单性和生产力。它也是一种完全面向对象的编程语言。此外，Ruby 还具有优雅的语法，易于阅读且易于编写。

任何编程都需要管理各种数据类型。数据类型描述了特定类别的数据。它告诉机器应该如何处理程序中的数据。数据类型对于确定可以对数据进行哪些操作（包括可以执行的操作）至关重要。在本教程中，我们将 深入探讨 Ruby 中可用的数据类型。我们还将探索动态类型。利用这一特性，Ruby 可以自动确定变量的数据类型，而无需显式声明。让我们开始吧！

前提条件

要练习并实现本指南中演示的步骤，您将需要以下组件：

配置妥当的 Linux 系统。了解更多关于在 CloudSigma 上设置个人 Ubuntu 服务器.
配置妥当的 Ruby 开发环境。请查看在 Ubuntu 上安装 Ruby 的官方文档（使用 APT）.

Ruby 中的数据类型

Ruby 具有您在任何编程语言中都会遇到的所有常见数据类型：整数、浮点数、字符串、数组、符号、哈希等。接下来，我们将概述如何使用 Ruby 的各种数据类型。

步骤 1 – 整数

与数学类似，整数在计算机编程中是整数。其值可以是正数、负数或 0。值范围如下：

 {-∞, …, -1, 0, 1, …, ∞}

1	{-∞, …, -1, 0, 1, …, ∞}

是时候在 Ruby 中尝试整数了。第一个示例是在屏幕上打印一个简单的整数：

print 99
print "\n"

1 2	print 99 print "\n"

接下来，我们将使用一个整数变量。这里，变量 sample_int 包含一个整数值 (99)，并且 print 函数在屏幕上打印该变量值：

sample_int = 99
print sample_int
print "\n"

sample_int = 99

print sample_int

print "\n"

我们还可以对整数进行数学运算。以下示例演示了两个整数的简单求和：

sample_int = 99 + 100
print sample_int
print "\n"

sample_int = 99 + 100

print sample_int

print "\n"

当我们处理大数字时，我们经常使用逗号 (,) 来使其更易于阅读。例如，一百万 (1000000) 写为 1,000,000 以获得更好的可读性。虽然禁止使用逗号，但 Ruby 允许使用下划线 ( _) 作为分隔符。请看以下示例：

sample_int = 1_000_999
print sample_int
print "\n"

sample_int = 1_000_999

print sample_int

print "\n"

使用下划线可以提高代码的可读性，尤其是在处理大整数值时。

步骤 2 – 浮点数

一个 浮点数（简称 float）表示一个实数。与数学定义类似，实数可以是有理数或无理数。在 Ruby 中，浮点数基本上是包含小数点的数字。

让我们尝试在屏幕上打印一个浮点值：

print 55.66
print "\n"

1 2	print 55.66 print "\n"

下一个示例演示了如何声明一个浮点变量：

sample_float = 55.66
print sample_float
print "\n"

sample_float = 55.66

print sample_float

print "\n"

我们还可以对浮点值和变量执行各种数学运算。以下示例演示了两个浮点数的简单求和：

sample_float = 55.66 + 99.222
print sample_float
print "\n"

sample_float = 55.66 + 99.222

print sample_float

print "\n"

如果我们把一个浮点数和一个整数相加会怎么样？结果值将是浮点数。在以下示例中，尽管 55.0 是一个整数，但它被视为浮点数：

sample_float = 55.0 + 10
print sample_float
print "\n"

sample_float = 55.0 + 10

print sample_float

print "\n"

步骤 3 – 布尔值

布尔值 表示数学逻辑分支的真假值。在 Ruby 中，布尔数据类型由两个值表示： true 和 false:

大于
- 100 > 99: true
- 99 > 100: false
小于
- 500 < 999: true
- 999 < 500: false
等于
- 10 == 10: true
- 9 == 99: false

与数字类似，我们也可以存储一个 true 或 false 变量中的值。以下示例演示了此功能：

result = 9 == 99
print result
print "\n"

result = 9 == 99

print result

print "\n"

步骤 4 – 字符串

在编程中，字符串 表示为字符序列（字母、数字和符号）。在 Ruby 中，字符串存在于单引号（ '）或双引号（ "）中。我们已经详细介绍了在 Ruby 中使用字符串，所以这将是一个简短的章节。

以下示例是一个基本的 hello world Ruby 程序：

print "hello world!\n"

1	print "hello world!\n"

我们还可以将字符串存储在变量中。以下示例还结合了字符串拼接：

username = "Cloudsigma"
print "hello, " + username + "!\n"

1 2	username = "Cloudsigma" print "hello, " + username + "!\n"

步骤 5 – 数组

数组是一种数据结构，可以存储相同数据类型的固定大小的元素集合。它也可以被概念化为相同数据类型的变量集合。它是大多数现代编程语言中最基本的数据结构之一。

在 Ruby 中，数组的定义如下：

[value_1, value_2, …, value_N]

1	[value_1, value_2, …, value_N]

可以创建我们目前讨论过的任何其他数据类型（整数、浮点数和字符串）的数组。以下是一些示例：

整数：[-5, 0, 5]
浮点数：[-9.99, -6.99, -3.99, 0, 3.99]
字符串：[“the”, “quick”, “brown”, “fox”]

以下示例实现了所有这些类型的数组：

print [-5, 0, 5]
print "\n"
print [-9.99, -6.99, -3.99, 0, 3.99]
print "\n"
print ["the", "quick", "brown", "fox"]
print "\n"

print [-5, 0, 5]

print "\n"

print [-9.99, -6.99, -3.99, 0, 3.99]

print "\n"

print ["the", "quick", "brown", "fox"]

print "\n"

请注意，当 print 函数遇到数组时，它会在屏幕上打印整个数组。为了更方便，您经常会遇到作为变量的数组。让我们更新代码：

array_int = [-5, 0, 5]

print array_int
print "\n"
array_float = [-9.99, -6.99, -3.99, 0, 3.99]
print array_float
print "\n"
array_string = ["the", "quick", "brown", "fox"]
print array_string
print "\n"

array_int = [-5, 0, 5]

print array_int

print "\n"

array_float = [-9.99, -6.99, -3.99, 0, 3.99]

print array_float

print "\n"

array_string = ["the", "quick", "brown", "fox"]

print array_string

print "\n"

现在，我们可以处理数组中的单个元素：

array_int = [-5, 0, 5]
print array_int[2]
print "\n"
array_float = [-9.99, -6.99, -3.99, 0, 3.99]
print array_float[1]
print "\n"
array_string = ["the", "quick", "brown", "fox"]
print array_string[3]
print "\n"

array_int = [-5, 0, 5]

print array_int[2]

print "\n"

array_float = [-9.99, -6.99, -3.99, 0, 3.99]

print array_float[1]

print "\n"

array_string = ["the", "quick", "brown", "fox"]

print array_string[3]

print "\n"

请注意，在 Ruby 中，数组的索引值从 0 开始。

为了方便起见，Ruby 中的数组带有 .first 和 .last 方法，用于打印第一个和最后一个元素：

array_float = [-9.99, -6.99, -3.99, 0, 3.99]
puts array_float.first
puts array_float.last
print "\n"

array_float = [-9.99, -6.99, -3.99, 0, 3.99]

puts array_float.first

puts array_float.last

print "\n"

在 Ruby 中，数组还有另一个有趣的特性。它可以同时容纳不同类型的数据。例如，您可以存储字符串、符号，甚至其他数组：

mixed_array = [
        "hello",
        99.99,
        "world",
        [
            "the",
            "quick",
            "brown",
            "fox"
        ]
    ]

print mixed_array
print "\n"

print mixed_array[3]
print "\n"

mixed_array = [

"hello",

99.99,

"world",

[

"the",

"quick",

"brown",

"fox"

]

print mixed_array

print "\n"

print mixed_array[3]

print "\n"

步骤 6 – 符号

在 Ruby 中，一个符号是一种特殊的数据类型，其作用类似于标签或标识符。符号是不可变的，这意味着它们不能被更改。符号看起来就像在声明没有任何值的变量。

下面是一个符号的示例：

:time_zone

1	:time_zone

通常，符号用于标识重要的事情。然而，在其他情况下，字符串就足够了。

Ruby 作为一种面向对象的语言，将一切都视为对象（包括字符串），并具有其唯一的内存位置，即使字符串是完全相同的。然而，当您引用一个符号时，它在程序中的任何地方都是同一个对象，即同一个内存位置。

步骤 7 – 哈希

哈希是键和值的类似于字典的集合。通常，哈希用于存储相关数据，例如，关于用户的信息。

下面是一个哈希的快速示例。我们创建了一个哈希 user_info，其中包含用户的用户名和密码：

user_info = {
"username" => "HelloWorld999",
"password" => "password123"
}
print user_info
print "\n"

user_info = {

"username" => "HelloWorld999",

"password" => "password123"

}

print user_info

print "\n"

要检索键值对的值，我们必须使用键。以下示例演示了此过程：

user_info = {
"username" => "HelloWorld999",
"password" => "password123"
}

print user_info["username"]
print "\n"

user_info = {

"username" => "HelloWorld999",

"password" => "password123"

}

print user_info["username"]

print "\n"

Ruby 还允许使用略有不同的语法来定义哈希（ :，而不是 =>):

user_info = {
username: "HelloWorld999",
password: "password123"
}
print user_info[:password]
print "\n"

user_info = {

username: "HelloWorld999",

password: "password123"

}

print user_info[:password]

print "\n"

这种语法结构类似于其他语言中使用的语法，例如 JavaScript。在这种语法结构中，键被定义为符号。这就是为什么我们不使用 "username"，而是使用： username 来访问该值。

动态类型

您可能已经注意到，在声明变量时，我们不必显式分配数据类型。相反，变量的值决定了数据类型。Ruby 使用 动态类型，其中类型检查是在运行时执行的。相比之下，在 静态类型 编程语言（例如 C/C++）中，数据类型是在编译期间确定的。

在以下示例中，分配给变量 dyn_var 的所有值都是有效的：

dyn_var = 123
dyn_var = 456.789
dyn_var = true
dyn_var = "the quick brown fox"
dyn_var

dyn_var = 123

dyn_var = 456.789

dyn_var = true

dyn_var = "the quick brown fox"

dyn_var

在动态类型语言中，我们可以自由地重用现有变量来存储不同的数据类型。在这里，我们更新了前面的示例以演示这一现象：

dyn_var = 123
puts dyn_var
dyn_var = 456.789
dyn_var = true
dyn_var = "the quick brown fox"
puts dyn_var
dyn_var

dyn_var = 123

puts dyn_var

dyn_var = 456.789

dyn_var = true

dyn_var = "the quick brown fox"

puts dyn_var

dyn_var

如本例所示，每次分配新值时，它都会随时更改 dyn_var 的数据类型。这在将一种数据类型转换为另一种数据类型时非常有用。以下示例演示了这一点：

print "enter length: "
length = gets.chop
length = length.to_f
puts length

print "enter length: "

length = gets.chop

length = length.to_f

puts length

在这里，

因为键盘输入是字符串，所以 length 起初是一个字符串。
由于我们期望的值是浮点数，因此我们使用 to_f 方法将字符串值转换为浮点数。
由于值的改变， length 被分配了浮点数据类型。这就是我们在屏幕上打印其值时所看到的。

如果我们尝试将两种不同的数据类型混合在一起会发生什么？Ruby 将会报错。来看一下：

print 9 + "77"

1	print 9 + "77"

数据类型识别

在 Ruby 中，一切都被视为对象。Ruby 中的每个对象都自带方法 class。当被调用时，此方法会告知源的数据类型。以下是一些使用 class 方法的示例：

puts 55.class
puts (55.55).class
puts true.class
puts nil.class

puts 55.class

puts (55.55).class

puts true.class

puts nil.class

另一种辨别数据类型的方法是使用 kind_of? 方法。它会根据所请求的数据类型检查对象的数据类型，并返回一个布尔值。在以下示例中查看其效果：

puts 55.kind_of?(Float)
puts 55.kind_of?(Integer)

1 2	puts 55.kind_of?(Float) puts 55.kind_of?(Integer)

同样，还有另一个方法 is_a?，它用于比较数据类型并返回一个布尔值。唯一的区别是方法的名称。不过，它可能更受欢迎，因为对开发人员来说，它更容易阅读和理解。使用 is_a?:

puts 55.is_a?(Float)
puts 55.is_a?(Integer)

1 2	puts 55.is_a?(Float) puts 55.is_a?(Integer)

总结

使用任何编程语言都需要很好地理解它所支持的数据类型。在本指南中，我们探索了 Ruby 编程中最常用的数据类型。我们讨论并演示了整数、浮点数、字符串、符号、布尔值和哈希（并附有示例）。

看看我们博客中能帮助您探索 Ruby 的更多教程：

祝您编程愉快！

Preslav Dobrev

作者 · CloudSigma

Preslav Dobrev 是 CloudSigma 的创意设计师，专注于通过传统和创新营销渠道打造一致的企业形象。他擅长将艺术愿景与战略营销相融合，创造具有影响力的品牌叙事。

Ruby 数据类型概述

前提条件

Ruby 中的数据类型

步骤 1 – 整数

步骤 2 – 浮点数

步骤 3 – 布尔值

步骤 4 – 字符串

步骤 5 – 数组

步骤 6 – 符号

步骤 7 – 哈希

动态类型

数据类型识别

总结

Preslav Dobrev

评论