Ruby 数组
在 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方法遍历数组，并将每个元素打印到控制台。
$ ./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方法返回数组的字符串表示形式。 当我们需要快速检查数组的内容时，这很有用。
$ ./arraynew.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方法将数组的字符串表示形式打印到终端。
$ ./creation.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]
该数组包含数字，字符串，自定义对象，另一个数组和符号。
$ ./arrayobjects.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]
在这种情况下，[]字符用于访问数组元素。 上面的行返回numbers数组的第一个和第二个元素（数字 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!方法拉平数组。 它从内部数组中获取所有元素，并创建一个没有任何内部数组的新元素。
$ ./arrayofarrays.rb
4
1
2
2
4
11
12
[1, 2, 3, 2, 4, 6, 11, 12]
This is the output of the code example.
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方法。
$ ./printarray1.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方法迭代以下块长度时间，将值从 0 传递到length-1。 这些数字用作有关数组的索引。
integers.each_with_index do |num, idx|
puts "value #{num} has index #{idx}"
end
each_with_index迭代数组，并将元素及其索引传递到给定的块。 这样，我们可以轻松地一次打印元素及其索引。
$ ./printarray2.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
这是retrieval.rb程序的输出。
[]字符可用于访问数据。 这是许多其他编程语言所使用的访问数组中数据的传统方式。 它节省了一些打字。
#!/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
我们放置了任意数量的索引。 如果没有带有特定索引的元素，则为零。
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方法的第三种形式返回具有给定索引的元素。 如果索引位于数组元素之外，则该方法返回默认值，在本例中为"undefined"。 如果没有第二个参数，则fetch方法将引发IndexError。
puts lts.fetch(8) { |e| -2*e }
在fetch方法的最后一种形式中，我们有一个块。 如果找不到具有给定索引的值，则该方法将返回调用该块的值，并传入索引。
$ ./retrieval4.rb
0
5
undefined
-16
This is the output of the script.
我们将展示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.rb
b
["c", "f", "d"]
$ ./random.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，因为我们刚刚删除了所有元素。
$ ./basics.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!方法都修改了原始数组的内容。
$ ./twotypes.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 的三倍。 方法调用后，仅剩 1 个 2。
$ ./methods2.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，第三个为 3。
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.rb
["a", "b", "c", "d", "e", "f", "g"]
["a", "b"]
["x", "y", "z"]
这是modify.rb示例的输出。
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 中，但不在两个集合中。
$ ./setoperations.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]
This is the output of the example.
Ruby 数组选择，收集，映射方法
在下一个示例中，我们将介绍三种方法：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 数组。
