Ruby 数组 · ZetCode 中文系列教程

# 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 数组。