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

你可以使用compact:

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

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

例如，如果你正在做这样的事情:

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

那就不要。相反，在地图之前，拒绝你不想要的东西或选择你想要的东西:

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

I consider using compact to clean up a mess as a last-ditch effort to get rid of things we didn't handle correctly, usually because we didn't know what was coming at us. We should always know what sort of data is being thrown around in our program; Unexpected/unknown data is bad. Anytime I see nils in an array I'm working on, I dig into why they exist, and see if I can improve the code generating the array, rather than allow Ruby to waste time and memory generating nils then sifting through the array to remove them later.

'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}

就足够了。

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]

尝试使用reduce或inject。

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

  memo
}

我同意公认的答案，我们不应该映射和压缩，但不是出于同样的原因。

I feel deep inside that map then compact is equivalent to select then map. Consider: map is a one-to-one function. If you are mapping from some set of values, and you map, then you want one value in the output set for each value in the input set. If you are having to select before-hand, then you probably don't want a map on the set. If you are having to select afterwards (or compact) then you probably don't want a map on the set. In either case you are iterating twice over the entire set, when a reduce only needs to go once.

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