# Ruby 数组

> 原文： [https://zetcode.com/lang/rubytutorial/arrays/](https://zetcode.com/lang/rubytutorial/arrays/)

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

## Ruby 数组定义

变量一次只能容纳一项。 数组可以容纳多个项目。 这些项目称为数组的元素。 数组可以保存任何数据类型的对象。 每个元素都可以由索引引用。 数组从零开始。 第一个元素的索引为零。

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

```ruby
#!/usr/bin/ruby

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

nums.each do |num|
    puts num
end

```

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

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

```

该行创建了一个由五个整数组成的数组。 元素之间用逗号分隔，并放在方括号之间。

```ruby
nums.each do |num|
    puts num
end

```

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

```ruby
$ ./array.rb
1
2
3
4
5

```

这是程序的输出。

## Ruby 数组创建

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

```ruby
#!/usr/bin/ruby

nums = Array.new

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

puts nums

```

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

```ruby
nums = Array.new

```

创建一个数组对象。

```ruby
nums.push 1

```

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

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

```ruby
#!/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`方法可能有一些选项。

```ruby
a1 = Array.new 

```

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

```ruby
a2 = Array.new 3

```

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

```ruby
a3 = Array.new 6, "coin"

```

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

```ruby
a4 = Array.new [11]

```

第四个数组将具有一项。

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

```

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

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

```

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

```ruby
$ ./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 中创建数组的各种方法。

```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

```

我们创建三个由整数，字符串和小数组成的数组。

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

```

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

```ruby
animals = %w( donkey dog cat dolphin eagle )

```

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

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

```

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

```ruby
puts integers.inspect

```

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

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

```

这是代码示例的输出。

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

```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 对象放入各种数组中。

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

```

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

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

```

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

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

```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，...]`数组中。

```ruby
puts numbers.length

```

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

```ruby
puts numbers[0], numbers[1]

```

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

```ruby
puts numbers[3][0]
puts numbers[3][1]

```

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

```ruby
puts numbers[3][3][0]
puts numbers[3][3][1]

```

现在我们更加深入。 我们访问最里面的数组的元素。 `[3][3]`返回`[11, 12]`数组。 然后从该数组中获得第一个（11）和第二个（12）元素。

```ruby
puts numbers.flatten!.inspect

```

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

```ruby
$ ./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 打印数组内容

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

```ruby
#!/usr/bin/ruby

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

puts integers
puts integers.inspect

integers.each do |e|
    puts e
end

```

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

```ruby
puts integers

```

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

```ruby
puts integers.inspect

```

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

```ruby
integers.each do |e|
    puts e
end

```

`each`方法为数组中的每个元素调用一次块，并将该元素作为参数传递。 我们仅在每个元素上使用`puts`方法。

```ruby
$ ./printarray1.rb
1
2
3
4
5
[1, 2, 3, 4, 5]
1
2
3
4
5

```

该数组将打印到控制台三遍。

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

```ruby
#!/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`方法。

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

```

`length`方法返回数组的大小。 `times`方法迭代以下块长度时间，将值从 0 传递到`length-1`。 这些数字用作有关数组的索引。

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

```

`each_with_index`迭代数组，并将元素及其索引传递到给定的块。 这样，我们可以轻松地一次打印元素及其索引。

```ruby
$ ./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 读取数组元素

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

```ruby
#!/usr/bin/ruby

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

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

```

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

```ruby
puts lts.first
puts lts.last

```

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

```ruby
puts lts.at(3)

```

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

```ruby
$ ./retrieval.rb
a
h
d

```

这是`retrieval.rb`程序的输出。

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

```ruby
#!/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

```

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

```ruby
puts lts[0]
puts lts[-1]

```

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

```ruby
puts lts[0, 3].inspect

```

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

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

```

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

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

```ruby
#!/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`方法是可选的。 它用于获取更具可读性的输出。

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

```

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

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

```

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

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

```

我们放置了任意数量的索引。 如果没有带有特定索引的元素，则为零。

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

```

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

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

```

这是脚本的输出。

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

```ruby
#!/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`方法的几种形式。

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

```

第一行打印数组中的第一个元素。 第二行从数组末尾打印第二个元素。

```ruby
puts lts.fetch(8, 'undefined')

```

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

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

```

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

```ruby
$ ./retrieval4.rb
0
5
undefined
-16

```

This is the output of the script.

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

```ruby
#!/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，然后停止迭代并返回所有先前元素的数组。

```ruby
puts lts.take(4).inspect

```

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

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

```

在这里，我们从原始数组创建一个新数组。 在新数组中，所有字符都位于'f'字符之前。

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

```

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

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

```ruby
#!/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`方法的五个示例。

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

```

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

```ruby
puts lts.slice(0, 3).inspect

```

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

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

```

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

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

```

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

可以从数组中选择一个随机数。 Ruby 为此具有`sample`方法。

```ruby
#!/usr/bin/ruby

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

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

```

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

```ruby
$ ./random.rb
b
["c", "f", "d"]
$ ./random.rb
d
["c", "d", "e"]

```

两次运行示例将得出不同的结果。

## Ruby 数组操作

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

```ruby
#!/usr/bin/ruby

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

puts num1 + num2 
puts num1.concat num2

```

我们有两个数组。 我们添加这两个数组。

```ruby
puts num1 + num2 
puts num1.concat num2

```

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

Ruby 有很多使用数组的方法。 例如，`length`方法返回数组中的元素数。

```ruby
#!/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?

```

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

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

```

`length`方法确定数组的大小。

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

```

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

```ruby
puts lts.eql? lts.dup

```

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

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

```

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

```ruby
lts.clear

```

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

```ruby
puts lts.empty?

```

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

```ruby
$ ./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 习惯用法。 感叹号告诉程序员该方法将修改数据。 感叹号本身没有任何作用。 它只是一个命名约定。

```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!`方法都修改了原始数组的内容。

```ruby
$ ./twotypes.rb
["e", "d", "c", "b", "a"]
["a", "b", "c", "d", "e"]
["e", "d", "c", "b", "a"]
["e", "d", "c", "b", "a"]

```

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

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

```ruby
#!/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

```

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

```ruby
puts numbers.index 2
puts numbers.index 11

```

`index`方法返回数组元素的索引。 它从左边返回第一个元素的索引。 第一行返回 1，它是数组中前 2 个的索引。 数组中只有 11 个，其索引为 8。

```ruby
puts numbers.rindex 2

```

`rindex`从右边返回第一个元素的索引。 在我们的例子中，最右边的 2 具有索引 3。

```ruby
puts numbers.include? 3
puts numbers.include? 10

```

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

```ruby
puts numbers.join '-'

```

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

```ruby
puts numbers.uniq!.inspect

```

`uniq!`方法从数组中删除重复的元素。 我们数组中的数字是 2 的三倍。 方法调用后，仅剩 1 个 2。

```ruby
$ ./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 修改数组

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

```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

```

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

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

```

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

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

```

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

```ruby
lts << 'L' << 'M' 

```

`<<`是`push`方法的同义词。 它将元素添加到数组。 可以在链中调用此运算符/方法。

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

```

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

```ruby
lts.insert(3, 'D')

```

在这种情况下，`insert`方法会在特定索引处插入`"D"`字符。

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

```

使用上述数组插入方法，我们构建了此大写字母数组。

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

```ruby
#!/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

```

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

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

```

我们有 8 个元素组成的数组。

```ruby
lts.pop

```

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

```ruby
lts.shift

```

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

```ruby
lts.delete_at(0)

```

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

```ruby
puts lts.clear

```

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

```ruby
lts.delete('d')

```

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

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

```

在这里，我们看到了示例的输出。

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

```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`方法，该方法删除满足块中显示的条件的所有项目。

```ruby
nms.delete_if { |x| x < 0 }

```

此行从数组中删除所有负数。

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

```

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

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

```ruby
#!/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`方法。

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

```

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

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

```

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

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

```

这是`modify.rb`示例的输出。

## Ruby 集操作

在本节中，我们介绍适用于 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}" 

```

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

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

```

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

```ruby
union = nums1 | nums2

```

此操作是两个数组的并集。 这两个数组被添加。 最终数组中的每个元素仅显示一次。

```ruby
isect = A & B

```

以上操作是两组的交集。 结果是具有两个数组中都存在的元素的数组。 在我们的例子中，是 4 和 5。

```ruby
diff1  = A - B
diff2  = B - A

```

在这里，我们有两个不同的运算，也称为补数。 在第一行中，我们获得 A 中存在但在 B 中不存在的所有元素。在第二行中，我们获得属于 B 而不是 A 的所有元素。

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

```

在这里，我们有一个对称的差异。 对称差给出的元素要么在 A 要么在 B 中，但不在两个集合中。

```ruby
$ ./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`方法。

```ruby
#!/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

```

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

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

```

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

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

```

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

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

```

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

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

```

这些是新创建的数组。

## Ruby 数组排序元素

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

```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 数组方法来重组数组中的元素。

```ruby
puts "#{planets.sort}"  

```

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

```ruby
puts "#{planets.reverse}"

```

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

```ruby
puts "#{planets.shuffle}"

```

`shuffle`方法随机重组数组元素。

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

```

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

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