映射一个数组，仅修改符合特定条件的元素

Question

在 Ruby 中，以修改某些元素而其他元素保持不变的方式映射数组的最具表现力的方法是什么？

这是一种直接的方法：

old_a = ["a", "b", "c"]                         # ["a", "b", "c"]
new_a = old_a.map { |x| (x=="b" ? x+"!" : x) }  # ["a", "b!", "c"]

如果还不够的话，当然可以省略“leave-alone”情况：

new_a = old_a.map { |x| x+"!" if x=="b" }       # [nil, "b!", nil]

我想要的是这样的：

new_a = old_a.map_modifying_only_elements_where (Proc.new {|x| x == "b"}) 
        do |y|
          y + "!"
        end
# ["a", "b!", "c"]

在 Ruby 中是否有一些好的方法可以做到这一点（或者也许 Rails 有一些我还没有找到一种方便的方法）？

---

谢谢大家的回复。 虽然你们集体说服我最好只使用 map 和三元运算符，但你们中的一些人发布了非常有趣的答案！

Answer 1

因为数组是指针，所以这也有效：

a = ["hello", "to", "you", "dude"]
a.select {|i| i.length <= 3 }.each {|i| i << "!" }

puts a.inspect
# => ["hello", "to!", "you!", "dude"]

在循环中，确保使用更改对象的方法而不是创建新对象。 例如，upcase! 与 upcase 相比。

确切的过程取决于您到底想要实现什么目标。 很难通过 foo-bar 的例子给出明确的答案。

Answer 2

old_a.map! { |a| a == "b" ? a + "!" : a }

给出

=> ["a", "b!", "c"]

map! 修改接收器，因此 old_a 现在是返回的数组。

Answer 3

我同意地图声明本身就很好。 简单明了，而且很容易
供任何人维护。

如果你想要更复杂的东西，这个怎么样？

module Enumerable
  def enum_filter(&filter)
    FilteredEnumerator.new(self, &filter)
  end
  alias :on :enum_filter
  class FilteredEnumerator
    include Enumerable
    def initialize(enum, &filter)
      @enum, @filter = enum, filter
      if enum.respond_to?(:map!)
        def self.map!
          @enum.map! { |elt| @filter[elt] ? yield(elt) : elt }
        end
      end
    end
    def each
      @enum.each { |elt| yield(elt) if @filter[elt] }
    end
    def each_with_index
      @enum.each_with_index { |elt,index| yield(elt, index) if @filter[elt] } 
    end
    def map
      @enum.map { |elt| @filter[elt] ? yield(elt) : elt }
    end
    alias :and :enum_filter
    def or
      FilteredEnumerator.new(@enum) { |elt| @filter[elt] || yield(elt) }
    end
  end
end

%w{ a b c }.on { |x| x == 'b' }.map { |x| x + "!" } #=> [ 'a', 'b!', 'c' ]

require 'set'
Set.new(%w{ He likes dogs}).on { |x| x.length % 2 == 0 }.map! { |x| x.reverse } #=> #<Set: {"likes", "eH", "sgod"}>

('a'..'z').on { |x| x[0] % 6 == 0 }.or { |x| 'aeiouy'[x] }.to_a.join #=> "aefiloruxy"

Answer 4

您的 map 解决方案是最好的。 我不知道为什么你认为 map_modifying_only_elements_where 更好。 使用 map 更干净、更简洁，并且不需要多个块。

Answer 5

一行：

["a", "b", "c"].inject([]) { |cumulative, i| i == "b" ? (cumulative << "#{i}!") : cumulative }

在上面的代码中，您以 []“cumulative”开始。 当您通过枚举器进行枚举时（在我们的例子中为数组 ["a", "b", "c"]），累积项以及“当前”项被传递到我们的块（|cumulative, i|）并且我们的块的执行结果被分配给累积。 我上面所做的是当项目不是“b”时保持累积不变并附加“b！” 到累积数组并在为 b 时返回它。

上面有一个使用 select 的答案，这是执行（并记住）它的最简单方法。

您可以将 select 与 map 结合起来，以实现您正在寻找的内容：

 arr = ["a", "b", "c"].select { |i| i == "b" }.map { |i| "#{i}!" }
 => ["b!"]

在 select 块内，您可以指定元素的条件被“选中”。 这将返回一个数组。 您可以在结果数组上调用“map”以将感叹号附加到它。

Answer 6

Ruby 2.7+

从 2.7 开始就有了明确的答案。

Ruby 2.7 为此引入了 filter_map。 这是惯用且高效的，我希望它很快就会成为常态。

例如：

numbers = [1, 2, 5, 8, 10, 13]
enum.filter_map { |i| i * 2 if i.even? }
# => [4, 16, 20]

这是一个很好的读物主题。

希望这对某人有用！

Answer 7

如果你不需要旧的数组，我更喜欢地图！ 在这种情况下，因为您可以使用 ! 方法来表示您正在就地更改数组。

self.answers.map!{ |x| (x=="b" ? x+"!" : x) }

我更喜欢这个而不是：

new_map = self.old_map{ |x| (x=="b" ? x+"!" : x) }

Answer 8

它有几行长，但这里有一个替代方案：

oa = %w| a b c |
na = oa.partition { |a| a == 'b' }
na.first.collect! { |a| a+'!' }
na.flatten! #Add .sort! here if you wish
p na
# >> ["b!", "a", "c"]

在我看来，带有三元的收集似乎是最好的。

Answer 9

我发现实现此目的的最佳方法是使用 tap

arr = [1,2,3,4,5,6]
[].tap do |a|
  arr.each { |x| a << x if x%2==0 }
end