Ruby中的列表理解

为了进行等效于Python列表推导的操作，我正在执行以下操作：

some_array.select{|x| x % 2 == 0 }.collect{|x| x * 3}

是否有更好的方法来执行此操作……也许只用一个方法调用？

如果确实需要，可以创建一个像这样的Array＃comprehend方法：

class Array
  def comprehend(&block)
    return self if block.nil?
    self.collect(&block).compact
  end
end

some_array = [1, 2, 3, 4, 5, 6]
new_array = some_array.comprehend {|x| x * 3 if x % 2 == 0}
puts new_array

印刷品：

6
12
18

我可能会按照您的方式来做。

怎么样：

some_array.map {|x| x % 2 == 0 ? x * 3 : nil}.compact

稍微干净一点，至少符合我的口味，根据快速基准测试，比您的版本快15％...

我做了一个快速基准测试，比较了这三种选择，而map-compact似乎确实是最好的选择。

性能测试（路轨）

require 'test_helper'
require 'performance_test_help'

class ListComprehensionTest < ActionController::PerformanceTest

  TEST_ARRAY = (1..100).to_a

  def test_map_compact
    1000.times do
      TEST_ARRAY.map{|x| x % 2 == 0 ? x * 3 : nil}.compact
    end
  end

  def test_select_map
    1000.times do
      TEST_ARRAY.select{|x| x % 2 == 0 }.map{|x| x * 3}
    end
  end

  def test_inject
    1000.times do
      TEST_ARRAY.inject([]) {|all, x| all << x*3 if x % 2 == 0; all }
    end
  end

end

结果

/usr/bin/ruby1.8 -I"lib:test" "/usr/lib/ruby/gems/1.8/gems/rake-0.8.7/lib/rake/rake_test_loader.rb" "test/performance/list_comprehension_test.rb" -- --benchmark
Loaded suite /usr/lib/ruby/gems/1.8/gems/rake-0.8.7/lib/rake/rake_test_loader
Started
ListComprehensionTest#test_inject (1230 ms warmup)
           wall_time: 1221 ms
              memory: 0.00 KB
             objects: 0
             gc_runs: 0
             gc_time: 0 ms
.ListComprehensionTest#test_map_compact (860 ms warmup)
           wall_time: 855 ms
              memory: 0.00 KB
             objects: 0
             gc_runs: 0
             gc_time: 0 ms
.ListComprehensionTest#test_select_map (961 ms warmup)
           wall_time: 955 ms
              memory: 0.00 KB
             objects: 0
             gc_runs: 0
             gc_time: 0 ms
.
Finished in 66.683039 seconds.

15 tests, 0 assertions, 0 failures, 0 errors

在这个线程中，Ruby程序员似乎对列表理解有些困惑。每个单个响应都假定要转换一些预先存在的数组。但是列表理解的能力在于使用以下语法动态创建的数组：

squares = [x**2 for x in range(10)]

以下是Ruby中的类似物（该线程中唯一的适当答案，AFAIC）：

a = Array.new(4).map{rand(2**49..2**50)} 

在上述情况下，我正在创建一个随机整数数组，但是该块可以包含任何内容。但这将是一个Ruby列表理解。

我与Rein Henrichs讨论了这个话题，他告诉我效果最好的解决方案是

map { ... }.compact

这很有道理，因为它避免了像不变使用那样构建中间Enumerable#injectArray，并且避免了增大Array从而导致分配的问题。除非您的集合可以包含nil个元素，否则它与其他任何一个元素一样通用。

我没有将此与

select {...}.map{...}

Ruby的C实现Enumerable#select也可能非常好。

将在每个实现中运行并在O（n）而不是O（2n）时间中运行的替代解决方案是：

some_array.inject([]){|res,x| x % 2 == 0 ? res << 3*x : res}

我刚刚将理解的gem发布到了RubyGems，这使您可以执行此操作：

require 'comprehend'

some_array.comprehend{ |x| x * 3 if x % 2 == 0 }

用C写的；该数组仅被遍历一次。

Enumerable有一个grep方法，其第一个参数可以是谓词proc，第二个可选参数是一个映射函数。所以以下工作：

some_array.grep(proc {|x| x % 2 == 0}) {|x| x*3}

它不像其他一些建议那样可读（我喜欢anoiaque的简单select.map或histocrat的理解的gem），但是它的优势在于它已经是标准库的一部分，并且是单遍的，并且不涉及创建临时的中间数组。 ，并且不需要-using建议nil中compact使用的越界值。

这更简洁：

[1,2,3,4,5,6].select(&:even?).map{|x| x*3}

[1, 2, 3, 4, 5, 6].collect{|x| x * 3 if x % 2 == 0}.compact
=> [6, 12, 18]

这对我行得通。也很干净。是的，它与相同map，但是我认为collect使代码更易于理解。

select(&:even?).map()

在下面看到之后，实际上看起来更好。

像佩德罗提到的，你可以链式调用融合在一起，以Enumerable#select和Enumerable#map，避免过度所选元素遍历。这是正确的，因为Enumerable#select是fold或的特殊化inject。我在Ruby subreddit上草率介绍了该主题。

手动融合Array转换可能很乏味，因此也许有人可以使用Robert Gamble的comprehend实现来使此select/ map模式更漂亮。

像这样：

def lazy(collection, &blk)
   collection.map{|x| blk.call(x)}.compact
end

称它为：

lazy (1..6){|x| x * 3 if x.even?}

哪个返回：

=> [6, 12, 18]

另一种解决方案，但可能不是最佳解决方案

some_array.flat_map {|x| x % 2 == 0 ? [x * 3] : [] }

要么

some_array.each_with_object([]) {|x, list| x % 2 == 0 ? list.push(x * 3) : nil }

这是解决此问题的一种方法：

c = -> x do $*.clear             
  if x['if'] && x[0] != 'f' .  
    y = x[0...x.index('for')]    
    x = x[x.index('for')..-1]
    (x.insert(x.index(x.split[3]) + x.split[3].length, " do $* << #{y}")
    x.insert(x.length, "end; $*")
    eval(x)
    $*)
  elsif x['if'] && x[0] == 'f'
    (x.insert(x.index(x.split[3]) + x.split[3].length, " do $* << x")
    x.insert(x.length, "end; $*")
    eval(x)
    $*)
  elsif !x['if'] && x[0] != 'f'
    y = x[0...x.index('for')]
    x = x[x.index('for')..-1]
    (x.insert(x.index(x.split[3]) + x.split[3].length, " do $* << #{y}")
    x.insert(x.length, "end; $*")
    eval(x)
    $*)
  else
    eval(x.split[3]).to_a
  end
end 

因此，基本上，我们将字符串转换为正确的ruby语法进行循环，然后可以在字符串中使用python语法来执行以下操作：

c['for x in 1..10']
c['for x in 1..10 if x.even?']
c['x**2 for x in 1..10 if x.even?']
c['x**2 for x in 1..10']

# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# [2, 4, 6, 8, 10]
# [4, 16, 36, 64, 100]
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

或者，如果您不喜欢字符串的外观或必须使用lambda，我们可以放弃尝试镜像python语法并尝试执行以下操作：

S = [for x in 0...9 do $* << x*2 if x.even? end, $*][1]
# [0, 4, 8, 12, 16]

Ruby 2.7引入filter_map了几乎可以实现您想要的功能（map + compact）：

some_array.filter_map { |x| x * 3 if x % 2 == 0 }

您可以在此处了解更多信息。

https://rubygems.org/gems/ruby_list_comprehension

我的Ruby List Comprehension gem的无耻插件，允许惯用的Ruby list comprehensions

$l[for x in 1..10 do x + 2 end] #=> [3, 4, 5 ...]

我认为最能理解列表的内容如下：

some_array.select{ |x| x * 3 if x % 2 == 0 }

由于Ruby允许我们将条件放在表达式之后，因此获得的语法类似于列表理解的Python版本。另外，由于该select方法不包含任何等于的false值，因此将从结果列表中删除所有nil值，并且不需要调用compact，就像我们曾经使用map或collect代替的情况一样。