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

您可以使用 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 来清理混乱，作为最后的努力，以摆脱我们没有正确处理的事情，通常是因为我们不知道会发生什么。我们应该始终知道在我们的程序中抛出了什么样的数据；意外/未知数据是错误的。每当我在正在处理的数组中看到 nil 时，我都会深入研究它们存在的原因，看看我是否可以改进生成数组的代码，而不是让 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 只需要执行一次。

此外，在英语中，您正在尝试“将一组整数减少为一组偶数”。

---

红宝石 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 adds Enumerable#filter_map”是关于这个主题的好读物，有一些针对这个问题的早期方法的一些性能基准：

N = 100_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] - [nil]
 => [1, 3]

---

在您的示例中：

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 方法。

[10, nil, 30, 40, nil].compact => [10, 30, 40]

---

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 的目的是什么。如果我假设您要通过传递一些 url 来处理 x 的值，并确定哪些 x 真正被处理为有效的非零结果 - 那么，可能是 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]

---