如何在Ruby中映射和删除nil值

我有一个map更改值或将其设置为nil的方法。然后，我想从列表中删除零个条目。该列表不需要保留。

这是我目前拥有的：

# A simple example function, which returns a value or nil
def transform(n)
  rand > 0.5 ? n * 10 : nil }
end

items.map! { |x| transform(x) } # [1, 2, 3, 4, 5] => [10, nil, 30, 40, nil]
items.reject! { |x| x.nil? } # [10, nil, 30, 40, nil] => [10, 30, 40]

我知道我可以做一个循环并有条件地收集在另一个数组中，如下所示：

new_items = []
items.each do |x|
    x = transform(x)
    new_items.append(x) unless x.nil?
end
items = new_items

但这似乎不是惯用法。有没有一种很好的方法可以在列表上映射函数，从而可以在移动过程中删除/排除nil？

Ruby 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]

在您的情况下，由于该块的评估结果为假，因此只需：

items.filter_map { |x| process_x url }

“ Ruby 2.7添加了Enumerable＃filter_map ”是关于该主题的不错的阅读，它针对一些较早的解决此问题的方法提供了性能基准：

N = 1_00_000
enum = 1.upto(1_000)
Benchmark.bmbm do |x|
  x.report("select + map")  { N.times { enum.select { |i| i.even? }.map{|i| i + 1} } }
  x.report("map + compact") { N.times { enum.map { |i| i + 1 if i.even? }.compact } }
  x.report("filter_map")    { N.times { enum.filter_map { |i| i + 1 if i.even? } } }
end

# Rehearsal -------------------------------------------------
# select + map    8.569651   0.051319   8.620970 (  8.632449)
# map + compact   7.392666   0.133964   7.526630 (  7.538013)
# filter_map      6.923772   0.022314   6.946086 (  6.956135)
# --------------------------------------- total: 23.093686sec
# 
#                     user     system      total        real
# select + map    8.550637   0.033190   8.583827 (  8.597627)
# map + compact   7.263667   0.131180   7.394847 (  7.405570)
# filter_map      6.761388   0.018223   6.779611 (  6.790559)

您可以使用compact：

[1, nil, 3, nil, nil].compact
=> [1, 3] 

我想提醒人们，如果您得到一个包含nils的数组作为一个map块的输出，并且该块试图有条件地返回值，那么您就有了代码味道，需要重新考虑一下逻辑。

例如，如果您正在执行以下操作：

[1,2,3].map{ |i|
  if i % 2 == 0
    i
  end
}
# => [nil, 2, nil]

那不要 相反，在之前map，reject您不需要或想要的东西select：

[1,2,3].select{ |i| i % 2 == 0 }.map{ |i|
  i
}
# => [2]

我考虑compact用来清理混乱，这是最后的努力，以摆脱我们未能正确处理的事情，通常是因为我们不知道会发生什么。我们应该始终知道程序中会抛出什么样的数据。意外/未知数据是错误的。每当我看到正在处理的数组中的nils时，我都会研究它们为什么存在，并查看是否可以改进生成数组的代码，而不是让Ruby浪费时间和内存来生成nil，然后在数组中进行筛选以将其删除他们以后。

'Just my $%0.2f.' % [2.to_f/100]

尝试使用reduce或inject。

[1, 2, 3].reduce([]) { |memo, i|
  if i % 2 == 0
    memo << i
  end

  memo
}

我同意接受的答案，希望大家不要map和compact，而不是出于同样的原因。

我觉得内心深处是map那么compact相当于select然后map。考虑：map是一对一功能。如果要从一组值映射为，则为map，则需要在输出集中为输入集中的每个值提供一个值。如果您需要select事先准备，那么您可能不希望map在此背景片上出现。如果您必须select事后（或compact），那么您可能不希望map在此背景上出现。无论哪种情况，您都需要遍历整个集合两次，而一次reduce只需要进行一次。

另外，您正在尝试用英语“将一组整数简化为一组偶数整数”。

在您的示例中：

items.map! { |x| process_x url } # [1, 2, 3, 4, 5] => [1, nil, 3, nil, nil]

除了被替换为以外，其他值似乎没有变化nil。如果是这样，则：

items.select{|x| process_x url}

就足够了。

如果您想要一个宽松的拒绝标准，例如，拒绝空字符串和nil，则可以使用：

[1, nil, 3, 0, ''].reject(&:blank?)
 => [1, 3, 0] 

如果您想走得更远并拒绝零值（或对流程应用更复杂的逻辑），则可以传递一个块以拒绝：

[1, nil, 3, 0, ''].reject do |value| value.blank? || value==0 end
 => [1, 3]

[1, nil, 3, 0, '', 1000].reject do |value| value.blank? || value==0 || value>10 end
 => [1, 3]

绝对compact是解决此任务的最佳方法。但是，我们可以通过简单的减法获得相同的结果：

[1, nil, 3, nil, nil] - [nil]
 => [1, 3]

each_with_object 可能是最干净的方法：

new_items = items.each_with_object([]) do |x, memo|
    ret = process_x(x)
    memo << ret unless ret.nil?
end

我认为，在有条件的情况下，each_with_object它优于inject/ reduce，因为您不必担心该块的返回值。

达到此目的的另一种方法如下所示。在这里，我们Enumerable#each_with_object用来收集值，并利用它Object#tap来消除nil检查process_x方法结果所需的临时变量。

items.each_with_object([]) {|x, obj| (process x).tap {|r| obj << r unless r.nil?}}

完整的示例说明：

items = [1,2,3,4,5]
def process x
    rand(10) > 5 ? nil : x
end

items.each_with_object([]) {|x, obj| (process x).tap {|r| obj << r unless r.nil?}}

替代方法：

通过查看您正在调用的方法process_x url，尚不清楚x该方法中输入的目的。如果我假设您要x通过传递一些值来处理的值，url并确定哪个xs真正被处理成有效的非nil结果-那么，可能Enumerabble.group_by是比更好的选择Enumerable#map。

h = items.group_by {|x| (process x).nil? ? "Bad" : "Good"}
#=> {"Bad"=>[1, 2], "Good"=>[3, 4, 5]}

h["Good"]
#=> [3,4,5]