Ruby 数组

最后修改于 2023 年 10 月 18 日

在本 Ruby 教程中，我们将介绍数组。数组是对象的有序集合。

Ruby 数组定义

一个变量一次只能保存一个项目。数组可以保存多个项目。这些项目称为数组的元素。数组可以保存任何数据类型的对象。每个元素都可以通过索引引用。数组是基于零的。第一个元素的索引是零。

请注意，Ruby 数组与 C、C++ 或 Java 等语言中的数组有很大不同。

#!/usr/bin/ruby

nums = [1, 2, 3, 4, 5]

nums.each do |num|
    puts num
end

我们的第一个示例创建一个包含五个整数的数组。数组的元素被打印到控制台。

nums = [1, 2, 3, 4, 5]

这行代码创建一个包含五个整数的数组。元素之间用逗号分隔，并放在方括号之间。

nums.each do |num|
    puts num
end

我们使用 each 方法遍历数组，并将每个元素打印到控制台。

$ ./simple_array.rb
1
2
3
4
5

Ruby 数组创建

Ruby 中的数组是一个对象。可以使用 new 方法实例化数组。

#!/usr/bin/ruby

nums = Array.new

nums.push 1
nums.push 2
nums.push 3
nums.push 4
nums.push 5

puts nums

在脚本中，我们首先创建一个 nums 数组。然后，我们向其中添加五个整数。

nums = Array.new

创建一个数组对象。

nums.push 1

push 方法将一个项目追加到数组的末尾。

我们继续使用 new 方法创建数组对象。

#!/usr/bin/ruby

a1 = Array.new
a2 = Array.new 3
a3 = Array.new 6, "coin"
a4 = Array.new [11]
a5 = Array.new (15) {|e| e * e}

puts [a1, a2, a3, a4, a5].inspect

Array 类的 new 方法可以接受一些选项。

a1 = Array.new

创建一个空数组。我们应该稍后用数据填充它。

a2 = Array.new 3

在这里，我们创建了一个包含三个 nil 对象的数组。

a3 = Array.new 6, "coin"

创建了一个包含六个 "coin" 字符串的数组。第一个选项是数组的大小。第二个选项是填充数组的对象。

a4 = Array.new [11]

第四个数组将有一个项目。

a5 = Array.new (15) {|e| e * e}

我们创建一个包含 15 个元素的数组。每个元素都在块中创建。我们在那里计算一个平方整数序列。

puts [a1, a2, a3, a4, a5].inspect

我们将所有数组放入一个数组中。数组可以放入其他数组中。然后，我们对数组调用 inspect 方法。这将对它的所有元素调用该方法。inspect 方法返回数组的字符串表示形式。当我们快速检查数组的内容时，这很有用。

$ ./array_new2.rb
[[], [nil, nil, nil], ["coin", "coin", "coin", "coin", "coin", "coin"],
[11], [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196]]

我们可以看到所有已创建数组的内容。

以下脚本展示了在 Ruby 中创建数组的各种方法。

#!/usr/bin/ruby

integers = [1, 2, 3, 4, 5]
animals = %w( donkey dog cat dolphin eagle )
weights = Array.new
weights << 4.55 << 3.22 << 3.55 << 8.55 << 3.23

puts integers.inspect
puts animals.inspect
puts weights.inspect

我们创建了三个包含整数、字符串和小数的数组。

integers = [1, 2, 3, 4, 5]

这行代码创建一个包含 5 个整数的数组。这是经典的数组创建方式。数组的元素放在方括号之间，并用逗号分隔。

animals = %w( donkey dog cat dolphin eagle )

该代码行使用五个元素创建一个字符串数组。在这种模式下，我们节省了一些输入。我们不使用逗号和双引号。

weights = Array.new
weights << 4.55 << 3.22 << 3.55 << 8.55 << 3.23

在第三种方式中，有两个步骤。首先，我们创建一个 Array 对象，然后使用数据初始化它。这是一种正式的数组创建方式。上述方式实际上是这种表示法的简写。

puts integers.inspect

inspect 方法将数组的字符串表示形式打印到终端。

$ ./create_array.rb
[1, 2, 3, 4, 5]
["donkey", "dog", "cat", "dolphin", "eagle"]
[4.55, 3.22, 3.55, 8.55, 3.23]

数组项目不仅限于数字和字符串。数组可以包含所有 Ruby 数据类型。

#!/usr/bin/ruby

class Empty

end

nums = [1, 2, 3, 4, 5]

various = [1, -1, "big", 3.4, Empty.new, nums, :two]

puts various.inspect

我们将各种 Ruby 对象放入各种数组中。

various = [1, -1, "big", 3.4, Empty.new, nums, :two]

数组包含数字、一个字符串、一个自定义对象、另一个数组和一个符号。

$ ./array_objects.rb
[1, -1, "big", 3.4, #<Empty:0x987f704>, [1, 2, 3, 4, 5], :two]

运行 arrayobjects.rb 示例，我们收到此输出。

最后一个示例展示了一个嵌套数组；一个数组在另一个数组中。在 Ruby 中，可以将数组嵌套到数组中。

#!/usr/bin/ruby

numbers = [1, 2, 3, [2, 4, 6, [11, 12]]]

puts numbers.length
puts numbers[0], numbers[1]

puts numbers[3][0]
puts numbers[3][1]

puts numbers[3][3][0]
puts numbers[3][3][1]

puts numbers.flatten!.inspect

数组 [11, 12] 嵌套在 [2, 4, 6, ...] 数组中，后者也嵌套在 [1, 2, 3, ...] 数组中。

puts numbers.length

length 方法返回 4。内部数组被计为一个元素。

puts numbers[0], numbers[1]

[] 字符在这种情况下用于访问数组元素。上面的代码行返回数字数组的第一个和第二个元素（数字 1 和 2）。方括号内的数字是数组的索引。第一个索引是 0，它返回第一个元素。

puts numbers[3][0]
puts numbers[3][1]

在这里，我们访问嵌套数组中的元素。[3] 抓取第四个元素，它是一个数组，[2, 4, 6, [11, 12]]。[3][0] 返回内部数组的第一个元素，在本例中为数字 2。以类似的方式，[3][1] 返回内部数组的第二个元素，即数字 4。

puts numbers[3][3][0]
puts numbers[3][3][1]

现在我们更深入地研究。我们访问最内层数组的元素。[3][3] 返回 [11, 12] 数组。从这个数组中，我们得到第一个 (11) 和第二个 (12) 元素。

puts numbers.flatten!.inspect

flatten! 方法展平数组。它从内部数组中获取所有元素并创建一个新数组，没有任何内部数组。

$ ./nested_arrays.rb
4
1
2
2
4
11
12
[1, 2, 3, 2, 4, 6, 11, 12]

Ruby 打印数组内容

一个常见的任务是将数组元素打印到控制台。我们有几种方法可以完成这项任务。

#!/usr/bin/ruby

integers = [1, 2, 3, 4, 5]

puts integers
puts integers.inspect

integers.each do |e|
    puts e
end

在此脚本中，我们将数组的所有元素打印三次。

puts integers

将数组作为参数传递给 puts 或 print 方法是打印数组内容的最简单方法。每个元素都打印在单独的行上。

puts integers.inspect

使用 inspect 方法，输出更具可读性。该行将数组的字符串表示形式打印到终端。

integers.each do |e|
    puts e
end

each 方法为数组中的每个元素调用一个块，并将该元素作为参数传递。我们只需对每个元素使用 puts 方法即可。

$ ./print_array1.rb
1
2
3
4
5
[1, 2, 3, 4, 5]
1
2
3
4
5

数组在控制台中打印三次。

在第二个示例中，我们提供了另外两种打印数组元素的方法。

#!/usr/bin/ruby

integers = [1, 2, 3, 4, 5]

integers.length.times do |idx|
    puts integers[idx]
end

integers.each_with_index do |num, idx|
    puts "value #{num} has index #{idx}"
end

在第一种情况下，我们使用 length 和 times 方法的组合。在第二种情况下，我们使用 each_with_index 方法。

integers.length.times do |idx|
    puts integers[idx]
end

length 方法返回数组的大小。times 方法将对以下块迭代 length 次，传递从 0 到 length-1 的值。这些数字用作相关数组的索引。

integers.each_with_index do |num, idx|
    puts "value #{num} has index #{idx}"
end

each_with_index 迭代数组并将元素及其索引传递给给定的块。通过这种方式，我们可以轻松地在一个操作中打印元素及其索引。

$ ./print_array2.rb
1
2
3
4
5
value 1 has index 0
value 2 has index 1
value 3 has index 2
value 4 has index 3
value 5 has index 4

Ruby 读取数组元素

在本节中，我们从数组中读取数据。

#!/usr/bin/ruby

lts = %w{ a b c d e f g h}

puts lts.first
puts lts.last
puts lts.at(3)

在第一个示例中，我们展示了三种简单的数据检索方法。

puts lts.first
puts lts.last

first 方法读取数组的第一个元素。last 方法读取数组的最后一个元素。

puts lts.at(3)

at 方法返回具有特定索引的数组元素。这行代码读取数组的第四个元素。

$ ./retrieval.rb
a
h
d

[] 字符可用于访问数据。这是许多其他编程语言中访问数组数据的传统方式。它节省了一些输入。

#!/usr/bin/ruby

lts = %w{ a b c d e f g h }

puts lts[0]
puts lts[-1]
puts lts[0, 3].inspect
puts lts[2..6].inspect
puts lts[2...6].inspect

我们展示了使用 [] 字符读取数据的五个示例。

puts lts[0]
puts lts[-1]

我们获取数组的第一个和最后一个项目。我们将项目的索引号放在 [] 字符之间。第一个项目的索引为 0，最后一个项目的索引为 -1。

puts lts[0, 3].inspect

当我们在方括号之间有两个数字时，第一个是起始索引，第二个是长度。在此代码行中，我们返回从索引 0 开始的 3 个元素。请注意，inspect 方法是可选的，它仅用于生成更具可读性的输出。

puts lts[2..6].inspect
puts lts[2...6].inspect

我们可以在方括号内使用范围运算符。在第一行中，我们读取从索引 2 到 6 的元素，在第二行中，我们读取从 2 到 5 的元素。

接下来我们演示 values_at 方法。此方法的优点是我们可以将多个索引放在 [] 字符之间以获取各种元素。

#!/usr/bin/ruby

lts = %w{ a b c d e f g h}

puts lts.values_at(1..5).inspect
puts lts.values_at(1, 3, 5).inspect
puts lts.values_at(1, 3, 5, 6, 8).inspect
puts lts.values_at(-1, -3).inspect

values_at 方法返回一个包含与给定选择器对应的元素的数组。inspect 方法是可选的。它用于获得更具可读性的输出。

puts lts.values_at(1..5).inspect

这行代码返回索引为 1 到 5 的元素。

puts lts.values_at(1, 3, 5).inspect

在这里，我们读取索引为 1、3 和 5 的元素。

puts lts.values_at(1, 3, 5, 6, 8).inspect

我们可以放置任意数量的索引。如果没有任何元素具有特定的索引，我们将得到 nil。

puts lts.values_at(-1, -3).inspect

负索引从数组的末尾返回元素。

$ ./retrieval3.rb
["b", "c", "d", "e", "f"]
["b", "d", "f"]
["b", "d", "f", "g", nil]
["h", "f"]

我们使用 fetch 方法从数组中读取数据。

#!/usr/bin/ruby

lts = [0, 1, 2, 3, 4, 5, 6]

puts lts.fetch(0)
puts lts.fetch(-2)
puts lts.fetch(8, 'undefined')
puts lts.fetch(8) { |e| -2 * e }

我们展示了使用 fetch 方法的几种形式。

puts lts.fetch(0)
puts lts.fetch(-2)

第一行打印数组的第一个元素。第二行打印数组的倒数第二个元素。

puts lts.fetch(8, 'undefined')

fetch 方法的第三种形式返回具有给定索引的元素。如果索引位于数组元素之外，则该方法将返回默认值，在本例中为“未定义”。如果没有第二个参数，fetch 方法将引发 IndexError。

puts lts.fetch(8) { |e| -2 * e }

在 fetch 方法的最后一种形式中，我们有一个块。如果找不到具有给定索引的值，则该方法将返回调用块的值，并传递索引。

$ ./retrieval4.rb
0
5
undefined
-16

我们展示了 take 和 take_while 方法的用法。

#!/usr/bin/ruby

lts = %w{ a b c d e f g h}


puts lts.take(4).inspect

lts2 = lts.take_while { |e| e < 'f' }
puts lts2.inspect

take n 方法返回数组的前 n 个元素。take_while 方法将元素传递给块，直到该块返回 nil 或 false，然后停止迭代并返回一个包含所有先前元素的数组。

puts lts.take(4).inspect

在这里，我们返回数组的前四个元素。

lts2 = lts.take_while { |e| e < 'f' }
puts lts2.inspect

在这里，我们从原始数组创建一个新数组。在新数组中，我们拥有“f”字符之前的所有字符。

$ ./retrieval5.rb
["a", "b", "c", "d"]
["a", "b", "c", "d", "e"]

在这里，我们看到了 retrieval5.rb 程序的输出。

slice 方法与 [] 字符相同。该方法从数组中返回一个或多个元素。

#!/usr/bin/ruby

lts = %w{ a b c d e f g h}

puts lts.slice(0)
puts lts.slice(-1)
puts lts.slice(0, 3).inspect
puts lts.slice(2..6).inspect
puts lts.slice(2...6).inspect

我们展示了 slice 方法的五个示例。

puts lts.slice(0)
puts lts.slice(-1)

这些形式的 slice 方法返回一个数组元素。第一行代码返回第一个元素，第二行返回 lts 数组的最后一个元素。

puts lts.slice(0, 3).inspect

第一个参数是起始索引，第二个参数是长度。在此代码行中，我们返回从索引 0 开始的 3 个元素。

puts lts.slice(2..6).inspect
puts lts.slice(2...6).inspect

我们可以将范围运算符与 slice 方法一起使用。在第一行中，我们读取从索引 2 到 6 的元素，在第二行中，我们读取从 2 到 5 的元素。

$ ./retrieval6.rb
a
h
["a", "b", "c"]
["c", "d", "e", "f", "g"]
["c", "d", "e", "f"]

slice 方法返回数组的一部分，一个或多个数组元素。

可以从数组中选择一个随机值。Ruby 有一个用于此的 sample 方法。

#!/usr/bin/ruby

lts = %w{ a b c d e f g h}

puts lts.sample
puts lts.sample(3).inspect

sample 方法有两种形式。在第一种形式中，我们选择一个随机元素。在第二种形式中，我们从数组中选择 n 个随机元素。

$ ./random_values.rb
b
["c", "f", "d"]
$ ./random_values.rb
d
["c", "d", "e"]

两次运行该示例会给出不同的结果。

Ruby 数组操作

在以下示例中，我们介绍了几个 Ruby 数组方法。

#!/usr/bin/ruby

num1 = [1, 2, 3, 4, 5]
num2 = [6, 7, 8, 9, 10]

puts num1 + num2
puts num1.concat num2

我们有两个数组。我们将这两个数组相加。

puts num1 + num2
puts num1.concat num2

有两种方法可以添加数组。我们可以使用 + 运算符或 concat 方法。结果是相同的。

Ruby 有很多处理数组的方法。例如，length 方法返回数组中元素的数量。

#!/usr/bin/ruby

lts = %w{ a b c d e f}

puts lts.inspect
puts "Array has #{lts.length} elements"
puts "The first element is #{lts.first}"
puts "The last element is #{lts.last}"

puts lts.eql? lts.dup
puts lts.eql? lts.dup.delete_at(0)

lts.clear
puts lts.inspect
puts lts.empty?

在上面的脚本中，我们介绍了七个新方法。

puts "Array has #{lts.length} elements"

length 方法确定数组的大小。

puts "The first element is #{lts.first}"
puts "The last element is #{lts.last}"

在这里，我们获取数组的第一个和最后一个元素。

puts lts.eql? lts.dup

eql? 方法确定两个数组是否相等。在我们的例子中，该行返回 true。dup 方法创建一个对象的浅表副本。它继承自 Object 父类。

puts lts.eql? lts.dup.delete_at(0)

delete_at 方法删除数组的第一个元素。这次这两个数组不相等。

lts.clear

clear 方法从数组中删除所有元素。

puts lts.empty?

empty? 方法检查数组是否为空。在我们的例子中，该代码行返回 true，因为我们刚刚删除了它的所有元素。

$ ./basic_methods.rb
["a", "b", "c", "d", "e", "f"]
Array has 6 elements
The first element is a
The last element is f
true
false
[]
true

一些 Ruby 数组方法以感叹号结尾。这是一个 Ruby 惯用法。感叹号告诉程序员该方法将修改数据。感叹号本身没有任何效果。它仅仅是一种命名约定。

#!/usr/bin/ruby

chars = %w{a b c d e}

reversed_chars = chars.reverse
puts reversed_chars.inspect
puts chars.inspect

reversed_chars = chars.reverse!
puts reversed_chars.inspect
puts chars.inspect

Ruby 拥有 reverse 方法和 reverse! 方法等两种类似的方法。这两种方法都会更改元素的顺序，即反转它。区别在于 reverse 方法返回一个反向数组，并保持原始数组不变，而 reverse! 方法既修改了原始数组的内容。

$ ./two_types.rb
["e", "d", "c", "b", "a"]
["a", "b", "c", "d", "e"]
["e", "d", "c", "b", "a"]
["e", "d", "c", "b", "a"]

我们可以清楚地看到前两个数组是不同的。第三个和第四个数组是相同的。

接下来的代码示例将介绍其他一些方法。

#!/usr/bin/ruby

numbers = [1, 2, 2, 2, 3, 4, 5, 8, 11]

puts numbers.index 2
puts numbers.index 11
puts numbers.rindex 2

puts numbers.include? 3
puts numbers.include? 10

puts numbers.join '-'
puts numbers.uniq!.inspect

我们介绍了另外五个方法。

puts numbers.index 2
puts numbers.index 11

index 方法返回数组元素的索引。它返回数组中第一个元素的索引（从左侧开始）。第一行返回 1，这是数组中第一个 2 的索引。数组中只有一个 11，它的索引是 8。

puts numbers.rindex 2

rindex 返回数组中最后一个元素的索引（从右侧开始）。在我们的例子中，最右边的 2 的索引是 3。

puts numbers.include? 3
puts numbers.include? 10

include? 方法检查数组中是否存在某个元素。第一行返回 true；3 存在。第二行返回 false；我们的数组中没有 10。按照惯例，以问号结尾的 Ruby 方法返回一个布尔值。同样，问号对数组没有任何影响。它仅仅是程序员的提示。

puts numbers.join '-'

join 方法返回一个由数组元素创建的字符串，并由提供的分隔符分隔。

puts numbers.uniq!.inspect

uniq! 方法从数组中删除重复的元素。我们的数组中有三个数字 2。在方法调用之后，将只剩下一个 2。

$ ./other_methods.rb
1
8
3
true
false
1-2-2-2-3-4-5-8-11
[1, 2, 3, 4, 5, 8, 11]

注意 join 方法的产物。它是一个字符串，其中数组的数字由 - 字符连接。

Ruby 修改数组

在本节中，我们将更深入地研究修改数组的方法。基本上，我们在数组上执行各种插入和删除操作。

#!/usr/bin/ruby

lts = []

lts.insert 0, 'E', 'F', 'G'
lts.push 'H'
lts.push 'I', 'J', 'K'
lts << 'L' << 'M'
lts.unshift 'A', 'B', 'C'
lts.insert(3, 'D')

puts lts.inspect

我们从一个空数组开始。我们使用不同的插入方法构建数组。

lts.insert 0, 'E', 'F', 'G'

insert 方法将三个元素插入到 lts 数组中。第一个字母的索引为 0，第二个字母的索引为 1，第三个字母的索引为 2。

lts.push 'H'
lts.push 'I', 'J', 'K'

push 方法将元素追加到数组中。我们可以追加一个或多个元素。

lts << 'L' << 'M'

<< 是 push 方法的同义词。它将一个元素追加到数组中。这个运算符/方法可以链式调用。

lts.unshift 'A', 'B', 'C'

unshift 方法将元素添加到数组的前面。

lts.insert(3, 'D')

在这种情况下，insert 方法将字符 'D' 插入到特定的索引位置。

$ ./insertion.rb
["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M"]

使用上述的数组插入方法，我们构建了这个由大写字母组成的数组。

有几种删除数组元素的方法。

#!/usr/bin/ruby

lts = %w{ a b c d e f g h}

lts.pop
lts.pop

puts lts.inspect

lts.shift
lts.shift

puts lts.inspect

lts.delete_at(0)
lts.delete('d')

puts lts.inspect

puts lts.clear
puts lts.inspect

在这个脚本中，我们演示了五种从数组中删除元素的方法。

lts = %w{ a b c d e f g h}

我们有一个包含 8 个元素的数组。

lts.pop

pop 方法从数组中删除最后一个元素。

lts.shift

shift 方法从数组中删除第一个元素。

lts.delete_at(0)

delete_at 删除特定位置的元素。我们删除剩余元素中的第一个元素。

puts lts.clear

clear 方法清除数组中的所有元素。

lts.delete('d')

delete 方法从数组中删除特定项目。

$ ./deletion.rb
["a", "b", "c", "d", "e", "f"]
["c", "d", "e", "f"]
["e", "f"]
[]

这里我们看到了例子的输出。

到目前为止，我们已经使用了通过一次添加或删除一个项目来修改数组的方法（除了 clear 方法）。Ruby 有一次影响多个数组项的方法。

#!/usr/bin/ruby

nms = [2, -1, -4, 0, 4, 3, -2, 3, 5]

nms.delete_if { |x| x < 0 }

puts nms.inspect

此示例引入了 delete_if 方法，该方法删除满足块中提出的条件的所有项目。

nms.delete_if { |x| x < 0 }

这行代码从数组中删除所有负数。

$ ./delete_if.rb
[2, 0, 4, 3, 3, 5]

我们已经从 nms 数组中删除了所有负数。

我们介绍了另外两种处理多个数组项的方法。

#!/usr/bin/ruby

lts = %w{ a b c d e f g}

puts lts.inspect

lts.reject! do |e|
    e =~ /[c-y]/
end

puts lts.inspect

lts.replace(["x", "y", "z"])
puts lts.inspect

我们使用两种方法，reject! 方法和 replace 方法。

lts.reject! do |e|
    e =~ /[c-y]/
end

reject! 方法删除所有满足块内特定条件的数组项。在我们的例子中，我们删除所有符合正则表达式的字母；任何从 c 到 y 的字母。=~ 运算符将字符串与正则表达式进行匹配。

lts.replace(["x", "y", "z"])

replace 方法将用其他给定的项目替换项目。如果需要，它会截断或扩展数组。

$ ./modify_array.rb
["a", "b", "c", "d", "e", "f", "g"]
["a", "b"]
["x", "y", "z"]

Ruby 集合操作

在本节中，我们将介绍适用于 Ruby 数组的集合操作。在数学中，集合是不同对象的集合。

#!/usr/bin/ruby

A = [1, 2, 3, 4, 5]
B = [4, 5, 6, 7, 8]

union = A | B
isect = A & B
diff1  = A - B
diff2  = B - A
sdiff = (A - B) | (B - A)

puts "Union of arrays: #{union}"
puts "Intersection of arrays: #{isect}"
puts "Difference of arrays A - B: #{diff1}"
puts "Difference of arrays B - A: #{diff2}"
puts "Symmetric difference of arrays: #{sdiff}"

在上面的脚本中，我们演示了几种集合操作，并集、交集、差集和对称差集。

nums1 = [1, 2, 3, 4, 5]
nums2 = [4, 5, 6, 7, 8]

我们定义了两个整数数组。两者都是集合，因为数组中的每个元素只出现一次。这两个数组有两个共同的数字，即 4 和 5。

union = nums1 | nums2

此操作是两个数组的并集。添加了两个数组。最终数组中的每个元素只出现一次。

isect = A & B

上述操作是两个集合的交集。结果是一个包含两个数组中都存在的元素的数组。在我们的例子中，是 4 和 5。

diff1  = A - B
diff2  = B - A

这里我们有两个差集操作，也称为补集。在第一行中，我们得到 A 中存在但 B 中不存在的所有元素。在第二行中，我们得到 B 中存在但 A 中不存在的所有元素。

sdiff = (A - B) | (B - A)

这里我们有一个对称差集。对称差集给出 A 或 B 中存在的元素，但不同时存在于两个集合中。

$ ./set_operations.rb
Union of arrays: [1, 2, 3, 4, 5, 6, 7, 8]
Intersection of arrays: [4, 5]
Difference of arrays A - B: [1, 2, 3]
Difference of arrays B - A: [6, 7, 8]
Symmetric difference of arrays: [1, 2, 3, 6, 7, 8]

Ruby 数组 select、collect、map 方法

在下一个例子中，我们介绍了三种方法：select、collect 和 map 方法。

#!/usr/bin/ruby

nums = [1, 3, 2, 6, 7, 12, 8, 15]

selected = nums.select do |e|
    e > 10
end

puts selected.inspect

collected = nums.collect do |e|
    e < 10
end

puts collected.inspect

mapped = nums.map do |e|
    e * 2
end

puts mapped.inspect

所有这些方法都对数组的元素执行批量操作。

selected = nums.select do |e|
    e > 10
end

在上面的代码中，我们使用 select 方法创建一个新数组。对于新创建的数组，我们选择满足块内条件的元素。在我们的例子中，我们选择所有大于 10 的元素。

collected = nums.collect do |e|
    e < 10
end

collect 方法的工作方式略有不同。它为每个元素调用附加的块，并返回块中的值。新数组包含 true、false 值。

mapped = nums.map do |e|
    e * 2
end

map 方法的工作方式与 collect 方法相同。在上面的行中，我们从现有数组创建一个新数组。每个元素乘以 2。

$ ./mass.rb
[12, 15]
[true, true, true, true, true, false, true, false]
[2, 6, 4, 12, 14, 24, 16, 30]

这些是新创建的数组。

Ruby 数组排序元素

最后，我们将对数组中的元素进行排序。

#!/usr/bin/ruby

planets = %w{ Mercury Venus Earth Mars Jupiter
                Saturn Uranus Neptune Pluto }

puts "#{planets.sort}"
puts "#{planets.reverse}"
puts "#{planets.shuffle}"

这个例子使用三种 Ruby 数组方法来重新组织数组中的元素。

puts "#{planets.sort}"

sort 方法按字母顺序对数组元素进行排序。

puts "#{planets.reverse}"

reverse 方法返回一个新数组，其中所有元素都按相反的顺序排列。

puts "#{planets.shuffle}"

shuffle 方法随机重新组织数组元素。

$ ./ordering.rb
["Earth", "Jupiter", "Mars", "Mercury", "Neptune", "Pluto", "Saturn", ...]
["Pluto", "Neptune", "Uranus", "Saturn", "Jupiter", "Mars", "Earth", ...]
["Earth", "Jupiter", "Mercury", "Saturn", "Mars", "Venus", "Uranus", ...]

这是代码示例的示例输出。

在本章中，我们使用了 Ruby 数组。