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

我有一个map，它要么改变一个值，要么将它设置为nil。然后我想从列表中删除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

但它看起来并不是那么地道。有没有一个很好的方法来映射一个函数在一个列表，删除/排除nils，因为你去?

319854 次浏览
小开

你可以使用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浪费时间和内存生成nils，然后筛选数组以在以后删除它们。

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

在你的例子中:

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

它看起来不像值发生了变化，而只是被nil替换了。如果是这样的话，那么:

items.select{|x| process_x url}

就足够了。

小开

compact绝对是解决这个任务的最佳方法。然而，我们可以通过简单的减法得到相同的结果:

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

如果你想要一个更宽松的拒绝标准，例如，拒绝空字符串以及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]
小开

尝试使用reduce或inject。

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


memo
}

我同意公认的答案，我们不应该map和compact，但不是出于同样的原因。

我内心深处觉得，map然后compact相当于select然后map。考虑:map是一个一对一的函数。如果你正在从某个值集进行映射，并且你map，那么你就为每个输入集的值compact2输出集中的一个值。如果你必须事先select，那么你可能不希望集合上有map。如果你随后必须select(或compact)，那么你可能不想在集合上使用map。在任何一种情况下，你都是在整个集合上迭代两次，而compact1只需要执行一次。

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

小开

完成它的另一种方法如下所示。这里，我们使用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真正被处理成有效的非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]
小开

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更好，因为你不必担心块的返回值。

小开
最佳答案

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添加了可枚举的#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方法。

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

提交答案