ruby-on-rails - Ruby(猴子修补数组)

Question

返回以获取有关我在 Bloc 的类(class)作业的更多帮助。决定让你们解决我在使用 Monkey 修补数组类时遇到的问题。这项任务有 8 个规范 需要满足，我现在只剩下一个了，我不知道该怎么做。

我只会向您提供我遇到问题的部分的 RSpec 和书面要求，因为其他一切似乎都已通过。此外，我将包括他们给我的入门脚手架，这样代码就不会出现混淆或无用的添加。

---

以下是 Array 类 Monkey 补丁的书面要求:

• 编写一个新的 new_map 方法，该方法在 Array 类的实例上调用。它应该使用它调用的数组作为隐式 (self) 参数，但其他方面的行为相同。 (未完成)

• 写一个new_select!行为类似于 select 的方法，但会改变调用它的数组。它可以使用 Ruby 内置的集合选择方法。 (完成)

---

以下是关于 Array 类需要满足的 RSpecs:

Note: "returns an array with updated values" Is the only Spec not passing.

describe Array do
  describe '#new_map' do
    it "returns an array with updated values" do
      array = [1,2,3,4]
      expect( array.new_map(&:to_s) ).to eq( %w{1 2 3 4} )
      expect( array.new_map{ |e| e + 2 } ).to eq( [3, 4, 5, 6] )
    end

    it "does not call #map" do
      array = [1,2,3,4]
      array.stub(:map) { '' }
      expect( array.new_map(&:to_s) ).to eq( %w{1 2 3 4} )
    end

    it "does not change the original array" do
      array = [1,2,3,4]
      expect( array.new_map(&:to_s) ).to eq( %w{1 2 3 4} )
      expect( array ).to eq([1,2,3,4])
    end
  end

  describe '#new_select!' do
    it "selects according to the block instructions" do
      expect( [1,2,3,4].new_select!{ |e| e > 2 } ).to eq( [3,4] )
      expect( [1,2,3,4].new_select!{ |e| e < 2 } ).to eq( [1] )
    end

    it "mutates the original collection" do
      array = [1,2,3,4]
      array.new_select!(&:even?)
      expect(array).to eq([2,4])
    end
  end
end

---

这是他们开始我的脚手架:

class Array
  def new_map
  end

  def new_select!(&block)
  end
end

---

最后，这是我的代码:

class Array
  def new_map 
    new_array = []
    self.each do |num|
      new_array << num.to_s
    end
    new_array
  end

  def new_select!(&block)
    self.select!(&block)
  end
end

Answer 1

Ruby Array Class:

map { |item| block } → new_ary

一个 block 就像一个方法，你在方法调用之后指定一个 block ，例如:

[1, 2, 3].map() {|x| x*2} #<---block
           ^
           |
       method call(usually written without the trailing parentheses)

block 被隐式发送到方法，在方法内部您可以使用 yield 调用 block 。

yield -> 在方法调用之后调用指定的 block 。在 ruby​​ 中，yield 等同于 yield()，在概念上等同于这样调用 block :block()。

yield(x) -> 在方法调用后调用指定的 block ，向它发送参数 x，这在概念上等同于这样调用 block :block(x).

所以，下面是如何实现 new_map() 的方法:

class Array
  def new_map
    result = []

    each do |item|
      result << yield(item)
    end

    result

  end
end

arr = [1, 2, 3].new_map {|x| x*2}
p arr

--output:--
[2, 4, 6]

这个注释有点高级，但是你实际上不必编写self.each() 来调用new_map() 中的each() 方法。所有方法都由某个对象调用，即点左侧的对象，称为接收器。例如，当你写:

self.each {....}

self 是方法调用 each() 的接收者。

如果你没有指定一个receiver而只写:

each {....}

...然后对于接收者，ruby 使用当时分配给 self 变量的任何对象。在上面的 new_map() 内部，ruby 会将调用 new_map() 方法的 Array 分配给 self，因此 each() 将遍历该 Array 中的项目。

您必须小心处理 self 变量，因为 ruby​​ 会在不通知您的情况下不断更改 self 变量的值。因此，您必须知道ruby 在代码中的任何特定点将什么分配给 self 变量——这是经验带来的。虽然，如果您想知道 ruby​​ 在代码中的某个特定点将什么对象分配给 self，您可以简单地写:

puts self

如果有经验的 ruby​​ 爱好者看到您在 new_map() 中编写 self.each {...}，他们会惊叫起来，但在我看来代码清晰 胜过代码技巧，因为对初学者来说将 self 写在那里更有意义，所以请继续这样做。当您获得更多经验并想炫耀时，您可以在不需要时消除显式接收器。这与显式返回的情况类似:

def some_method
    ...
    return result
end

和隐式返回:

def some_method
    ...
    result
end

请注意，您可以像这样编写 new_map():

class Array
  def new_map(&my_block)  #capture the block in a variable
    result = []

    each do |item|
      result << my_block.call(item) #call the block
    end

    result

  end
end

arr = [1, 2, 3].new_map {|x| x*2}
p arr

--output:--
[2, 4, 6]

将其与使用 yield() 的示例进行比较。当您使用 yield() 时，就好像 ruby​​ 为您创建了一个名为 yield 的参数变量，以便捕获该 block 。但是，对于 yield，您可以使用不同的语法来调用该 block ，即 ()，或者如果它们不是该 block 的参数，您可以消除括号——就像您调用方法。另一方面，当您创建自己的参数变量来捕获 block 时，例如def new_map(&my_block)，你必须使用不同的语法来调用 block :

1. my_block.call(arg1, ...)

或者:

1. myblock[arg1, ...]

请注意，#2 就像调用方法的语法一样——只是您用 [] 代替了 ()。

再一次，有经验的 ruby​​ists 将使用 yield 来调用 block ，而不是在参数变量中捕获 block 。但是，在某些情况下，您需要在参数变量中捕获 block ，例如如果您想将 block 传递给另一种方法。