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

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

Ruby 数组定义

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

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

  1. #!/usr/bin/ruby
  3. nums = [1, 2, 3, 4, 5]
  5. nums.each do |num|
  6.     puts num
  7. end

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

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

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

  1. nums.each do |num|
  2.     puts num
  3. end

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

  1. $ ./array.rb
  2. 1
  3. 2
  4. 3
  5. 4
  6. 5

这是程序的输出。

Ruby 数组创建

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

  1. #!/usr/bin/ruby
  3. nums = Array.new
  5. nums.push 1
  6. nums.push 2
  7. nums.push 3
  8. nums.push 4
  9. nums.push 5
  11. puts nums

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

  1. nums = Array.new

创建一个数组对象。

  1. nums.push 1

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

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

  1. #!/usr/bin/ruby
  3. a1 = Array.new 
  4. a2 = Array.new 3
  5. a3 = Array.new 6, "coin"
  6. a4 = Array.new [11]
  7. a5 = Array.new (15) {|e| e*e}
  9. puts [a1, a2, a3, a4, a5].inspect

Array类的new方法可能有一些选项。

  1. a1 = Array.new

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

  1. a2 = Array.new 3

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

  1. a3 = Array.new 6, "coin"

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

  1. a4 = Array.new [11]

第四个数组将具有一项。

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

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

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

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

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

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

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

  1. #!/usr/bin/ruby
  3. integers = [1, 2, 3, 4, 5]
  4. animals = %w( donkey dog cat dolphin eagle )
  5. weights = Array.new
  6. weights << 4.55 << 3.22 << 3.55 << 8.55 << 3.23
  8. puts integers.inspect
  9. puts animals.inspect
  10. puts weights.inspect

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

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

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

  1. animals = %w( donkey dog cat dolphin eagle )

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

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

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

  1. puts integers.inspect

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

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

这是代码示例的输出。

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

  1. #!/usr/bin/ruby
  3. class Empty
  5. end
  7. nums = [1, 2, 3, 4, 5]
  9. various = [1, -1, "big", 3.4, Empty.new, nums, :two]
  11. puts various.inspect

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

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

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

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

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

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

  1. #!/usr/bin/ruby
  3. numbers = [1, 2, 3, [2, 4, 6, [11, 12]]]
  5. puts numbers.length
  6. puts numbers[0], numbers[1]
  8. puts numbers[3][0]
  9. puts numbers[3][1]
  11. puts numbers[3][3][0]
  12. puts numbers[3][3][1]
  14. puts numbers.flatten!.inspect

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

  1. puts numbers.length

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

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

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

  1. puts numbers[3][0]
  2. puts numbers[3][1]

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

  1. puts numbers[3][3][0]
  2. puts numbers[3][3][1]

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

  1. puts numbers.flatten!.inspect

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

  1. $ ./arrayofarrays.rb
  2. 4
  3. 1
  4. 2
  5. 2
  6. 4
  7. 11
  8. 12
  9. [1, 2, 3, 2, 4, 6, 11, 12]

This is the output of the code example.

Ruby 打印数组内容

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

  1. #!/usr/bin/ruby
  3. integers = [1, 2, 3, 4, 5]
  5. puts integers
  6. puts integers.inspect
  8. integers.each do |e|
  9.     puts e
  10. end

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

  1. puts integers

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

  1. puts integers.inspect

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

  1. integers.each do |e|
  2.     puts e
  3. end

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

  1. $ ./printarray1.rb
  2. 1
  3. 2
  4. 3
  5. 4
  6. 5
  7. [1, 2, 3, 4, 5]
  8. 1
  9. 2
  10. 3
  11. 4
  12. 5

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

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

  1. #!/usr/bin/ruby
  3. integers = [1, 2, 3, 4, 5]
  5. integers.length.times do |idx|
  6.     puts integers[idx]
  7. end
  9. integers.each_with_index do |num, idx|
  10.     puts "value #{num} has index #{idx}"
  11. end

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

  1. integers.length.times do |idx|
  2.     puts integers[idx]
  3. end

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

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

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

  1. $ ./printarray2.rb
  2. 1
  3. 2
  4. 3
  5. 4
  6. 5
  7. value 1 has index 0
  8. value 2 has index 1
  9. value 3 has index 2
  10. value 4 has index 3
  11. value 5 has index 4

这是示例的输出。

Ruby 读取数组元素

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

  1. #!/usr/bin/ruby
  3. lts = %w{ a b c d e f g h}
  5. puts lts.first
  6. puts lts.last
  7. puts lts.at(3)

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

  1. puts lts.first
  2. puts lts.last

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

  1. puts lts.at(3)

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

  1. $ ./retrieval.rb
  2. a
  3. h
  4. d

这是retrieval.rb程序的输出。

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

  1. #!/usr/bin/ruby
  3. lts = %w{ a b c d e f g h }
  5. puts lts[0]
  6. puts lts[-1]
  7. puts lts[0, 3].inspect
  8. puts lts[2..6].inspect
  9. puts lts[2...6].inspect

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

  1. puts lts[0]
  2. puts lts[-1]

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

  1. puts lts[0, 3].inspect

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

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

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

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

  1. #!/usr/bin/ruby
  3. lts = %w{ a b c d e f g h}
  5. puts lts.values_at(1..5).inspect
  6. puts lts.values_at(1, 3, 5).inspect
  7. puts lts.values_at(1, 3, 5, 6, 8).inspect
  8. puts lts.values_at(-1, -3).inspect

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

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

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

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

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

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

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

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

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

  1. $ ./retrieval3.rb
  2. ["b", "c", "d", "e", "f"]
  3. ["b", "d", "f"]
  4. ["b", "d", "f", "g", nil]
  5. ["h", "f"]

这是脚本的输出。

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

  1. #!/usr/bin/ruby
  3. lts = [0, 1, 2, 3, 4, 5, 6]
  5. puts lts.fetch(0)
  6. puts lts.fetch(-2)
  7. puts lts.fetch(8, 'undefined')
  8. puts lts.fetch(8) { |e| -2*e }

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

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

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

  1. puts lts.fetch(8, 'undefined')

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

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

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

  1. $ ./retrieval4.rb
  2. 0
  3. 5
  4. undefined
  5. -16

This is the output of the script.

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

  1. #!/usr/bin/ruby
  3. lts = %w{ a b c d e f g h}
  5. puts lts.take(4).inspect
  7. lts2 = lts.take_while { |e| e < 'f' }
  8. puts lts2.inspect

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

  1. puts lts.take(4).inspect

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

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

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

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

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

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

  1. #!/usr/bin/ruby
  3. lts = %w{ a b c d e f g h}
  5. puts lts.slice(0)
  6. puts lts.slice(-1)
  7. puts lts.slice(0, 3).inspect
  8. puts lts.slice(2..6).inspect
  9. puts lts.slice(2...6).inspect

我们介绍slice方法的五个示例。

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

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

  1. puts lts.slice(0, 3).inspect

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

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

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

  1. $ ./retrieval6.rb
  2. a
  3. h
  4. ["a", "b", "c"]
  5. ["c", "d", "e", "f", "g"]
  6. ["c", "d", "e", "f"]

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

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

  1. #!/usr/bin/ruby
  3. lts = %w{ a b c d e f g h}
  5. puts lts.sample
  6. puts lts.sample(3).inspect

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

  1. $ ./random.rb
  2. b
  3. ["c", "f", "d"]
  4. $ ./random.rb
  5. d
  6. ["c", "d", "e"]

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

Ruby 数组操作

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

  1. #!/usr/bin/ruby
  3. num1 = [1, 2, 3, 4, 5]
  4. num2 = [6, 7, 8, 9, 10]
  6. puts num1 + num2 
  7. puts num1.concat num2

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

  1. puts num1 + num2 
  2. puts num1.concat num2

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

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

  1. #!/usr/bin/ruby
  3. lts = %w{ a b c d e f}
  5. puts lts.inspect
  6. puts "Array has #{lts.length} elements"
  7. puts "The first element is #{lts.first}"
  8. puts "The last element is #{lts.last}"
  10. puts lts.eql? lts.dup
  11. puts lts.eql? lts.dup.delete_at(0)
  13. lts.clear
  14. puts lts.inspect
  15. puts lts.empty?

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

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

length方法确定数组的大小。

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

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

  1. puts lts.eql? lts.dup

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

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

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

  1. lts.clear

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

  1. puts lts.empty?

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

  1. $ ./basics.rb
  2. ["a", "b", "c", "d", "e", "f"]
  3. Array has 6 elements
  4. The first element is a
  5. The last element is f
  6. true
  7. false
  8. []
  9. true

这是示例的输出。

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

  1. #!/usr/bin/ruby
  3. chars = %w{a b c d e}
  5. reversed_chars = chars.reverse
  6. puts reversed_chars.inspect
  7. puts chars.inspect
  9. reversed_chars = chars.reverse!
  10. puts reversed_chars.inspect
  11. puts chars.inspect

Ruby 除其他外，还有两种相似的方法，即reverse方法和reverse!方法。 这两种方法会更改元素的顺序，并将它们颠倒过来。 不同之处在于reverse方法返回一个反向数组，并使原始数组保持原样，而reverse!方法都修改了原始数组的内容。

  1. $ ./twotypes.rb
  2. ["e", "d", "c", "b", "a"]
  3. ["a", "b", "c", "d", "e"]
  4. ["e", "d", "c", "b", "a"]
  5. ["e", "d", "c", "b", "a"]

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

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

  1. #!/usr/bin/ruby
  3. numbers = [1, 2, 2, 2, 3, 4, 5, 8, 11]
  5. puts numbers.index 2
  6. puts numbers.index 11
  7. puts numbers.rindex 2
  9. puts numbers.include? 3
  10. puts numbers.include? 10
  12. puts numbers.join '-'
  13. puts numbers.uniq!.inspect

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

  1. puts numbers.index 2
  2. puts numbers.index 11

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

  1. puts numbers.rindex 2

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

  1. puts numbers.include? 3
  2. puts numbers.include? 10

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

  1. puts numbers.join '-'

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

  1. puts numbers.uniq!.inspect

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

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

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

Ruby 修改数组

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

  1. #!/usr/bin/ruby
  3. lts = []
  5. lts.insert 0, 'E', 'F', 'G'
  6. lts.push 'H'
  7. lts.push 'I', 'J', 'K'
  8. lts << 'L' << 'M' 
  9. lts.unshift 'A', 'B', 'C'
  10. lts.insert(3, 'D')
  12. puts lts.inspect

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

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

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

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

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

  1. lts << 'L' << 'M'

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

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

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

  1. lts.insert(3, 'D')

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

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

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

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

  1. #!/usr/bin/ruby
  3. lts = %w{ a b c d e f g h}
  5. lts.pop
  6. lts.pop
  8. puts lts.inspect
  10. lts.shift
  11. lts.shift
  13. puts lts.inspect
  15. lts.delete_at(0)
  16. lts.delete('d')
  18. puts lts.inspect
  20. puts lts.clear
  21. puts lts.inspect

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

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

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

  1. lts.pop

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

  1. lts.shift

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

  1. lts.delete_at(0)

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

  1. puts lts.clear

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

  1. lts.delete('d')

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

  1. $ ./deletion.rb
  2. ["a", "b", "c", "d", "e", "f"]
  3. ["c", "d", "e", "f"]
  4. ["e", "f"]
  5. []

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

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

  1. #!/usr/bin/ruby
  3. nms = [2, -1, -4, 0, 4, 3, -2, 3, 5]
  5. nms.delete_if { |x| x < 0 }
  7. puts nms.inspect

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

  1. nms.delete_if { |x| x < 0 }

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

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

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

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

  1. #!/usr/bin/ruby
  3. lts = %w{ a b c d e f g}
  5. puts lts.inspect
  7. lts.reject! do |e|
  8.     e =~ /[c-y]/
  9. end
  11. puts lts.inspect
  13. lts.replace(["x", "y", "z"])
  14. puts lts.inspect

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

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

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

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

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

  1. $ ./modify.rb 
  2. ["a", "b", "c", "d", "e", "f", "g"]
  3. ["a", "b"]
  4. ["x", "y", "z"]

这是modify.rb示例的输出。

Ruby 集操作

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

  1. #!/usr/bin/ruby
  3. A = [1, 2, 3, 4, 5]
  4. B = [4, 5, 6, 7, 8]
  6. union = A | B
  7. isect = A & B
  8. diff1  = A - B
  9. diff2  = B - A
  10. sdiff = (A - B) | (B - A)
  12. puts "Union of arrays: #{union}"
  13. puts "Intersection of arrays: #{isect}"
  14. puts "Difference of arrays A - B: #{diff1}"
  15. puts "Difference of arrays B - A: #{diff2}"    
  16. puts "Symmetric difference of arrays: #{sdiff}"

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

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

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

  1. union = nums1 | nums2

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

  1. isect = A & B

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

  1. diff1  = A - B
  2. diff2  = B - A

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

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

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

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

This is the output of the example.

Ruby 数组选择，收集，映射方法

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

  1. #!/usr/bin/ruby
  3. nums = [1, 3, 2, 6, 7, 12, 8, 15]
  5. selected = nums.select do |e|
  6.     e > 10
  7. end
  9. puts selected.inspect
  11. collected = nums.collect do |e|
  12.     e < 10
  13. end
  15. puts collected.inspect
  17. mapped = nums.map do |e|
  18.     e*2
  19. end
  21. puts mapped.inspect

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

  1. selected = nums.select do |e|
  2.     e > 10
  3. end

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

  1. collected = nums.collect do |e|
  2.     e < 10
  3. end

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

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

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

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

这些是新创建的数组。

Ruby 数组排序元素

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

  1. #!/usr/bin/ruby
  3. planets = %w{ Mercury Venus Earth Mars Jupiter
  4.                 Saturn Uranus Neptune Pluto }
  6. puts "#{planets.sort}"                
  7. puts "#{planets.reverse}"
  8. puts "#{planets.shuffle}"

该示例使用三种 Ruby 数组方法来重组数组中的元素。

  1. puts "#{planets.sort}"

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

  1. puts "#{planets.reverse}"

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

  1. puts "#{planets.shuffle}"

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

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

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

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