原文： https://zetcode.com/lang/rubytutorial/datatypes/

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

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

Ruby 数据类型列表

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

  • 布尔值
  • 符号
  • 数字
  • 字符串
  • 数组
  • 哈希

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

  1. #!/usr/bin/ruby
  3. h = { :name => "Jane", :age => 17 }
  5. p true.class, false.class
  6. p "Ruby".class
  7. p 1.class
  8. p 4.5.class
  9. p 3_463_456_457.class
  10. p :age.class
  11. p [1, 2, 3].class
  12. p h.class

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

  1. p true.class, false.class

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

  1. p "Ruby".class

这是字符串。

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

这些是数字。

  1. p :age.class

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

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

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

  1. $ ./types.rb
  2. TrueClass
  3. FalseClass
  4. String
  5. Fixnum
  6. Float
  7. Bignum
  8. Symbol
  9. Array
  10. Hash

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

Ruby 布尔值

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

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

  1. #!/usr/bin/ruby
  3. # kid.rb
  5. bool = [true, false]
  7. male = bool[rand(2)]
  9. if male
  10.     puts "We will use name John"
  11. else 
  12.     puts "We will use name Victoria"
  13. end

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

  1. bool = [true, false]

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

  1. male = bool[rand(2)]

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

  1. if male
  2.     puts "We will use name John"
  3. else 
  4.     puts "We will use name Victoria"
  5. end

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

  1. $ ./kid.rb 
  2. We will use name Victoria
  3. $ ./kid.rb 
  4. We will use name Victoria
  5. $ ./kid.rb 
  6. We will use name John
  7. $ ./kid.rb 
  8. We will use name John
  9. $ ./kid.rb 
  10. We will use name John

多次运行该程序。

Ruby 符号

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

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

  1. #!/usr/bin/ruby
  3. p :name
  4. p :name.class
  5. p :name.methods.size
  6. p "Jane".methods.size
  8. p :name.object_id
  9. p :name.object_id
  10. p "name".object_id
  11. p "name".object_id

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

  1. p :name
  2. p :name.class

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

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

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

  1. p :name.object_id
  2. p :name.object_id
  3. p "name".object_id
  4. p "name".object_id

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

  1. $ ./symbols.rb
  2. :name
  3. Symbol
  4. 79
  5. 162
  6. 10328
  7. 10328
  8. 77344750
  9. 77344730

样本输出。

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

  1. #!/usr/bin/ruby
  3. light = :on
  5. if light == :on
  6.     puts "The light is on"
  7. else
  8.     puts "The light is off"
  9. end
  11. light = :off
  13. if light == :on
  14.     puts "The light is on"
  15. else
  16.     puts "The light is off"
  17. end

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

  1. light = :on

灯亮。

  1. if light == :on
  2.     puts "The light is on"
  3. else
  4.     puts "The light is off"
  5. end

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

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

  1. #!/usr/bin/ruby
  3. domains = {:sk => "Slovakia", :no => "Norway", :hu => "Hungary"}
  5. puts domains[:sk]
  6. puts domains[:no]
  7. puts domains[:hu]

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

  1. puts domains[:sk]
  2. puts domains[:no]
  3. puts domains[:hu]

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

  1. $ ./symbols3.rb
  2. Slovakia
  3. Norway
  4. Hungary

示例的输出。

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

  1. #!/usr/bin/ruby
  3. class Being
  5.     def initialize
  6.         @is = true
  7.     end
  9.     def say
  10.         "I am being"
  11.     end
  12. end
  14. b = Being.new
  16. p b.method :say
  17. p b.instance_variable_get :@is

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

  1. p b.method :say

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

  1. p b.instance_variable_get :@is

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

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

生成的输出。

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

  1. #!/usr/bin/ruby
  3. def info
  4.   "info method"
  5. end
  7. @v = "Ruby"
  8. @@n = "16"
  10. p Symbol.all_symbols.include? :info
  11. p Symbol.all_symbols.include? :@v
  12. p Symbol.all_symbols.include? :@@n

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

  1. p Symbol.all_symbols.include? :info

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

  1. $ ./symbols5.rb
  2. true
  3. true
  4. 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。 程序员通常不需要关心整数的类类型。

  1. #!/usr/bin/ruby
  3. p -2
  4. p 121
  5. p 123265
  6. p -34253464356
  7. p 34867367893463476
  9. p 1.class
  10. p 23453246.class
  11. p 234532423563456346.class
  12. p 2345324235632363463456456346.class
  14. p 5 / 2
  15. p 5.div 2

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

  1. p -2
  2. p 121
  3. p 123265
  4. p -34253464356
  5. p 34867367893463476

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

  1. p 1.class
  2. p 23453246.class
  3. p 234532423563456346.class
  4. p 2345324235632363463456456346.class

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

  1. p 5 / 2
  2. p 5.div 2

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

  1. $ ./integers.rb
  2. -2
  3. 121
  4. 123265
  5. -34253464356
  6. 34867367893463476
  7. Fixnum
  8. Fixnum
  9. Bignum
  10. Bignum
  11. 2
  12. 2

示例的输出。

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

  1. #!/usr/bin/ruby
  3. puts 122
  4. puts 0x7a
  5. puts 0172
  6. puts 0b1111010

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

  1. $ ./inotations.rb
  2. 122
  3. 122
  4. 122
  5. 122

示例的输出。

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

  1. #!/usr/bin/ruby
  3. baskets = 16
  4. apples_in_basket = 24
  6. total = baskets * apples_in_basket
  8. puts "There are total of #{total} apples"

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

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

程序的输出。

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

  1. #!/usr/bin/ruby
  3. p 23482345629
  4. p 23_482_345_629
  6. p 23482345629 == 23_482_345_629

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

  1. p 23482345629 == 23_482_345_629

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

  1. $ ./underscore.rb
  2. 23482345629
  3. 23482345629
  4. true

示例输出。

Ruby 浮点数

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

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

  1. #!/usr/bin/ruby
  3. p 15.4
  4. p 0.3455
  5. p -343.4563
  7. p 12.5.class
  8. p -12.5.class
  9. p (5.0 / 2).class
  11. p 5.fdiv 2
  12. p 12.to_f

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

  1. p 15.4
  2. p 0.3455
  3. p -343.4563

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

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

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

  1. p 5.fdiv 2
  2. p 12.to_f

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

  1. $ ./decimals.rb
  2. 15.4
  3. 0.3455
  4. -343.4563
  5. Float
  6. Float
  7. Float
  8. 2.5
  9. 12.0

输出。

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

  1. #!/usr/bin/ruby
  3. p 1/3.0
  4. p 1.fdiv 2
  6. puts sprintf "%.4f" % (1/3.0)
  7. puts sprintf "%.7f" % (5/3.0)

格式化十进制数字。

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

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

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

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

  1. $ ./formatfloat.rb
  2. 0.3333333333333333
  3. 3.25
  4. 0.5
  5. 0.3333
  6. 1.6666667

Output.

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

  1. #!/usr/bin/ruby
  3. p 1.2e-3
  4. p 0.0012
  6. p 1.5E-4
  7. p 0.00015

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

  1. $ ./scientific.rb
  2. 0.0012
  3. 0.0012
  4. 0.00015
  5. 0.00015

这是上面程序的输出。

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

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

  1. #!/usr/bin/ruby
  3. require 'bigdecimal'
  5. sum = 0
  7. 1000.times do
  8.     sum = sum + 0.0001
  9. end
  11. p sum
  13. sum = BigDecimal.new("0")
  15. 1000.times do
  16.     sum = sum + BigDecimal.new("0.0001")
  17. end
  19. puts sum.to_s('F')
  20. puts sum.to_s('E')

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

  1. require 'bigdecimal'

必须导入BigDecimal类。

  1. sum = 0
  3. 1000.times do
  4.     sum = sum + 0.0001
  5. end
  7. p sum

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

  1. sum = BigDecimal.new("0")
  3. 1000.times do
  4.     sum = sum + BigDecimal.new("0.0001")
  5. end

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

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

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

  1. $ ./bigdecimal.rb
  2. 0.10000000000000184
  3. 0.1
  4. 0.1E0

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

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

  1. #!/usr/bin/ruby
  3. distance = 0.1
  4. time = 9.87 / 3600
  6. speed = distance / time
  8. puts "The average speed of a sprinter is #{speed} km/h"

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

  1. distance = 0.1

100m 是 0.1 公里。

  1. time = 9.87 / 3600

9.87s 是9.87 / 60 * 60 h

  1. speed = distance / time

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

  1. $ ./speed.rb
  2. 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，所以每个整数都是有理数。

  1. #!/usr/bin/ruby
  3. puts 2.to_r
  4. puts "23".to_r
  5. puts 2.6.to_r
  7. p Rational 0
  8. p Rational 1/5.0
  9. p Rational 0.5

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

  1. puts 2.to_r

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

  1. p Rational 0.5

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

  1. $ ./rational.rb
  2. 2/1
  3. 23/1
  4. 5854679515581645/2251799813685248
  5. (0/1)
  6. (3602879701896397/18014398509481984)
  7. (1/2)

Output of the example.

Ruby nil值

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

  1. #!/usr/bin/ruby
  3. puts nil
  4. p nil
  6. p $val
  8. p [1, 2, 3][4] 
  10. p $val1 == $val2

nil值的示例。

  1. puts nil
  2. p nil

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

  1. p $val

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

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

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

  1. p $val1 == $val2

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

  1. $ ./nilvalue.rb
  3. nil
  4. nil
  5. nil
  6. true

Output.

Ruby 字符串

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

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

  1. #!/usr/bin/ruby
  3. p "Ruby"
  4. p 'Python'
  6. p "Ruby".size
  7. p "Ruby".upcase
  9. p 23.to_s

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

  1. p "Ruby"
  2. p 'Python'

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

  1. p "Ruby".size
  2. p "Ruby".upcase

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

  1. p 23.to_s

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

  1. $ ./strings.rb
  2. "Ruby"
  3. "Python"
  4. 4
  5. "RUBY"
  6. "23"

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

Ruby 数组和哈希

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

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

  1. #!/usr/bin/ruby
  3. nums = [1, 2, 3, 4]
  5. puts "There are #{nums.size} items in the array"
  7. nums.each do |num|
  8.     puts num
  9. end
  11. domains = { :de => "Germany", :sk => "Slovakia",
  12.             :us => "United States", :no => "Norway" }
  14. puts domains.keys
  15. puts domains.values

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

  1. nums = [1, 2, 3, 4]
  3. puts "There are #{nums.size} items in the array"
  5. nums.each do |num|
  6.     puts num
  7. end

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

  1. domains = { :de => "Germany", :sk => "Slovakia",
  2.             :us => "United States", :no => "Norway" }
  4. puts domains.keys
  5. puts domains.values

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

  1. $ ./arrayshashes.rb
  2. There are 4 items in the array
  3. 1
  4. 2
  5. 3
  6. 4
  7. de
  8. sk
  9. us
  10. no
  11. Germany
  12. Slovakia
  13. United States
  14. Norway

Example output.

Ruby 转换

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

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

  1. #!/usr/bin/ruby
  3. p Array(1..6)
  4. p Complex 6
  5. p Float 12
  6. p Integer "34"
  7. p Rational 6
  8. p String 22

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

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

Output of the example.

  1. #!/usr/bin/ruby
  3. p "12".to_i
  4. p 12.5.to_i
  5. p nil.to_i
  7. p 12.to_f
  8. p "11".to_f
  9. p nil.to_f

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

  1. p "12".to_i
  2. p 12.5.to_i
  3. p nil.to_i

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

  1. p 12.to_f
  2. p "11".to_f
  3. p nil.to_f

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

  1. $ ./conversions.rb
  2. 12
  3. 12
  4. 0
  5. 12.0
  6. 11.0
  7. 0.0

Example output.

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

  1. #!/usr/bin/ruby
  3. p "12".to_i
  4. p "13".to_f
  5. p "12".to_r
  6. p "13".to_c
  8. p "Jane".to_sym
  10. v = "Ruby Python Tcl PHP Perl".split
  11. p v.class

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

  1. p "12".to_i
  2. p "13".to_f
  3. p "12".to_r
  4. p "13".to_c

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

  1. p "Jane".to_sym

字符串成为符号。

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

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

  1. $ ./stringconv.rb
  2. 12
  3. 13.0
  4. (12/1)
  5. (13+0i)
  6. :Jane
  7. Array

这就是我们得到的。

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

  1. #!/usr/bin/ruby
  3. h = {:de => "Germany", :sk => "Slovakia"}
  4. p h.to_a
  6. a = [:de, "Germany", :sk, "Slovakia", 
  7.      :hu, "Hungary", :no, "Norway"]
  8. p Hash[*a]

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

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

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

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

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

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

Output of the example.

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