Ruby 数据类型

数据类型对您正在处理的数据种类进行分类，例如文本、数字和真/假值。例如，

num = 24

在这里，24（一个整数）被赋值给 num 变量。因此，num 的数据类型是 Integer。

请注意，我们没有显式指定变量的数据类型。这是因为 Ruby 会自动推断变量的数据类型。这被称为动态类型。

Ruby 数据类型

下表列出了一些常见的 Ruby 数据类型

Ruby 数字（整数和浮点数）

整数是没有小数点的数字。

同时，浮点数是有小数点的数字。

例如，

# Create and print an integer variable
marks = 85
puts marks

# Create and print a float variable
price = 99.99
puts price

输出

85
99.99

这里，

• marks 是一个值为 85 的整数变量。
• price 是一个值为 99.99 的浮点数变量。

要了解更多信息，请访问我们的 Ruby 数字 教程。

# Display the sum of 9 and 3
puts 9 + 3

# Display the product of 2.5 and 6.9
puts 2.5 * 6.9

12
17.25

puts 9 / 4

# Output: 2

# Divide 9.0 (float) by 4 (integer)
puts 9.0 / 4
# Output: 2.25

# Divide 9 (integer) by 4.0 (float)
puts 9 / 4.0
# Output: 2.25

# Divide 9.0 by 4.0
puts 9.0 / 4.0
# Output: 2.25

Ruby 字符串

字符串是引号中的一段文本。例如，

message = "Hello, I'm 29 years old."
puts message

age = '29'
puts age

输出

Hello, I'm 29 years old.
29

在这里，message 和 age 是字符串变量，因为它们存储了包含在引号中的字符序列。

注意：您可以使用单引号和双引号来表示字符串。但是，我们建议您使用双引号。

要了解更多信息，请访问我们的 Ruby 字符串 教程。

字符串与数字

请注意，在上面的程序中，age 变量存储的是字符串 '29'。即使我们理解这是一个数字，Ruby 也会将其解释为字符串，因为该值被引号括起来了。

# String value because of single quotes 
age_string = '29'
puts age_string

# String value because of single quotes
price_string = "99.99"
puts price_string

# Integer value (no quotations present)
age_int = 29
puts age_int

# Float value (no quotations present)
price_float = 99.99
puts price_float

输出

29
99.99
29
99.99

这里，

• '29' 和 "99.99" 是字符串，因为它们分别用单引号和双引号括起来了数字值。
• 29 和 99.99 是数字，因为它们没有被引号括起来。

注意： puts 方法在打印字符串时不会显示引号。因此，puts '29' 和 puts 29 的输出都将是 29。

Ruby 布尔值

布尔值可以是 true 或 false。例如，

# Print boolean values
puts true
puts false

# Create boolean variables
can_vote = true
can_drink = false

# Print the boolean variables
puts can_vote
puts can_drink

输出

true
false
true
false

注意：布尔值用于条件语句和循环（我们将在后面的章节中学习）。

要了解更多信息，请访问 Ruby 布尔值。

Ruby 数组

数组是值的列表。例如，

array_int = [1, 2, 3]
puts array_int

输出

1
2
3

在这里，array_int 是一个包含三个整数值：1、2 和 3 的数组。

您也可以创建其他类型的数组。您还可以将不同类型的数据混合到单个数组中。例如，

# An array of floats
array_float = [1.1, 2.2, 3.3]
p array_float

# An array of strings
array_string = ["Black Sabbath", "Deep Purple", "Led Zeppelin"]
p array_string

# Mixed array
array_mixed = ["Ash Ketchum", 10, false]
p array_mixed

输出

[1.1, 2.2, 3.3]
["Black Sabbath", "Deep Purple", "Led Zeppelin"]
["Ash Ketchum", 10, false]

提示：打印数组或其他复杂数据结构时，请使用 p 而不是 puts。它会显示完整的结构（包括引号、括号等）。

要了解更多信息，请访问我们的 Ruby 数组 教程。

rock_bands = ["Black Sabbath", "Deep Purple", "Led Zeppelin"]

# Display the first element
puts rock_bands[0]

# Display the second element
puts rock_bands[1]

# Display the third element
puts rock_bands[2]

Black Sabbath
Deep Purple
Led Zeppelin

rock_bands[index]

Ruby 哈希

哈希存储键值对。它类似于其他编程语言中的字典类型。例如，

# Create a hash named 'student'
student = {
  "id" => 121,
  "name" => "Ash Ketchum",
  "age" => 10
}

# Print the value stored in key "id"
puts student["id"]

# Print the value stored in key "name"
puts student["name"]

# Print the value stored in key "age"
puts student["age"]

输出

121
Ash Ketchum
10

在这里，student 是一个哈希，存储了以下键值对

请注意

• 使用 => 符号将值赋给键。
• 我们通过指定键来访问值。例如，student["id"] 给出存储在 student 哈希中的 "id" 键的值（121）。

要了解更多信息，请访问 Ruby 哈希。

Ruby nil

Ruby 中的 nil 值表示“无”。这是 Ruby 表示“此处无值”的方式。

name = nil
puts name

此程序不打印任何内容，因为 nil 表示变量没有值。

Ruby 符号

符号是 Ruby 中一个轻量级的、不可变的标签。它常用于不需要完整字符串功能的场景，例如哈希中的键。

符号以冒号 (:) 开头。例如，

my_symbol = :hello
puts my_symbol

# Output: hello

在这里，my_symbol 是一个存储符号 :hello 的变量。

请注意，puts 方法在打印符号时不会显示冒号。

student = {
  id: 121,
  name: "Ash Ketchum",
  age: 10
}

puts student[:id]
puts student[:name]
puts student[:age]

121
Ash Ketchum
10

student = {
  id: 121,
  name: "Ash Ketchum",
  age: 10
}

puts student[:id]
puts student[:name]
puts student[:age]

student = {
  :id => 121,
  :name => "Ash Ketchum",
  :age => 10
}

puts "hello".class
# Output: String

puts :hello.class
# Output: Symbol

puts 123.class
# Output: Integer

puts 12.3.class
# Output: Float

puts true.class
# Output: TrueClass

puts false.class
# Output: FalseClass

puts nil.class
# Output: NilClass

my_array = [1, 2, 3]
puts my_array.class
# Output: Array

my_hash = { name: "Ragnar Lothbrok" }
puts my_hash.class
# Output: Hash

require 'complex'
puts Complex(2, 3) # Output: 2+3i

puts Rational(1, 2) # Output: 1/2