blocks|key|1683989|text|如果你真的想要，你可以像这样创建一个Array#comprehend方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1683990|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+{%7Cx%7C+x+*+3+if+x+%25+2+==+0}
puts+new_array|code-block|syntax|javascript|1683991|打印：|1683992|6
12
18|1683993|不过，我可能会像你那样做。|1683994|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If you really want to, you can create an Array#comprehend method like this:

<pre><code>class Array
 def comprehend(&amp;block)
 return self if block.nil?
 self.collect(&amp;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
</code></pre>

Prints:

<pre><code>6
12
18
</code></pre>

I would probably just do it the way you did though.

blocks|key|1468717|text|怎么样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1468718|some_array.map+{%7Cx%7C+x+%25+2+==+0+?+x+*+3+:+nil}.compact|code-block|syntax|javascript|1468719|稍微更干净，至少对我来说是这样，根据一个快速的基准测试，比你的版本快了15%25……|1468720|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

How 'bout:

<pre><code>some_array.map {|x| x % 2 == 0 ? x * 3 : nil}.compact
</code></pre>

Slightly cleaner, at least to my taste, and according to a quick benchmark test about 15% faster than your version...

blocks|key|1684152|text|我认为最能让人理解的列表如下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1684153|some_array.select{+%7Cx%7C+x+*+3+if+x+%25+2+==+0+}|code-block|syntax|javascript|1684154|因为Ruby允许我们将条件放在表达式后面，所以我们得到了类似于Python版本的列表理解的语法。此外，由于select方法不包含任何与false相等的内容，因此所有nil值都将从结果列表中删除，并且不需要像使用map或collect时那样调用压缩。|offset|length|style|CODE|1684155|entityMap^0|0|0|1H|6|1V|5|2X|3|31|7|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|N|$]]

I think the most list comprehension-esque would be the following:

<pre><code>some_array.select{ |x| x * 3 if x % 2 == 0 }
</code></pre>

Since Ruby allows us to place the conditional after the expression, we get syntax similar to the Python version of the list comprehension. Also, since the <code>select</code> method does not include anything that equates to <code>false</code>, all nil values are removed from the resultant list and no call to compact is necessary as would be the case if we had used <code>map</code> or <code>collect</code> instead.

blocks|key|1684221|text|另一种解决方案将在每个实现中工作，并在O(n)而不是O(2n)时间内运行：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1684222|some_array.inject([]){%7Cres,x%7C+x+%25+2+==+0+?+res+<<+3*x+:+res}|code-block|syntax|javascript|1684223|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

An alternative solution that will work in every implementation and run in O(n) instead of O(2n) time is:

<pre><code>some_array.inject([]){|res,x| x % 2 == 0 ? res &lt;&lt; 3*x : res}
</code></pre>

blocks|key|1684286|text|正如佩德罗提到的，您可以将对Enumerable#select和Enumerable#map的链接调用融合在一起，从而避免遍历选定的元素。这是正确的，因为Enumerable#select是fold或inject的特化。我在Ruby+subreddit上发布了这个主题的hasty+introduction。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1684287|手动融合数组转换可能很繁琐，所以也许有人可以尝试一下Robert+Gamble的comprehend实现，使这个select/map模式更漂亮。|1684288|entityMap|0|LINK|mutability|MUTABLE|url|http://www.reddit.com/r/ruby/comments/a13fm/a_60_second_fusion_tutorial_for_ruby/^0|E|H|W|E|25|H|2S|6|3R|I|0|0|14|A|1K|6|1R|3|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|F|3|G|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

Like Pedro mentioned, you can fuse together the chained calls to <code>Enumerable#select</code> and <code>Enumerable#map</code>, avoiding a traversal over the selected elements. This is true because <code>Enumerable#select</code> is a specialization of fold or <code>inject</code>. I posted a <a href="http://www.reddit.com/r/ruby/comments/a13fm/a_60_second_fusion_tutorial_for_ruby/" rel="nofollow noreferrer">hasty introduction</a> to the topic at the Ruby subreddit.

Manually fusing Array transformations can be tedious, so maybe someone could play with Robert Gamble's <code>comprehend</code> implementation to make this <code>select</code>/<code>map</code> pattern prettier.

blocks|key|1469018|text|这个更简洁：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1469019|[1,2,3,4,5,6].select(&:even?).map{%7Cx%7C+x*3}|code-block|syntax|javascript|1469020|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is more concise:

<pre><code>[1,2,3,4,5,6].select(&amp;:even?).map{|x| x*3}
</code></pre>

blocks|key|1469099|text|我和Rein+Henrich讨论了这个话题，他告诉我性能最佳的解决方案是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1469100|map+{+...+}.compact|code-block|syntax|javascript|1469101|这很有意义，因为它避免了使用Enumerable#inject的不可变用法构建中间数组，并且避免了导致分配的数组增长。它和其他任何元素一样通用，除非你的集合可以包含空元素。|offset|length|style|CODE|1469102|我还没有把这个和|1469103|select+{...}.map{...}|1469104|有可能Ruby的Enumerable#select的C实现也很好。|1469105|entityMap^0|0|0|E|H|0|0|0|8|H|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|11|8|@$I|12|J|13|K|L]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

I discussed this topic with Rein Henrichs, who tells me that the best performing solution is 

<pre><code>map { ... }.compact
</code></pre>

This makes good sense because it avoids building intermediate Arrays as with the immutable usage of <code>Enumerable#inject</code>, and it avoids growing the Array, which causes allocation. It's as general as any of the others unless your collection can contain nil elements.

I haven't compared this with

<pre><code>select {...}.map{...}
</code></pre>

It's possible that Ruby's C implementation of <code>Enumerable#select</code> is also very good.

blocks|key|1469173|text|在这个线程中，Ruby程序员似乎对什么是列表理解有一些困惑。每一个响应都假设要转换一些预先存在的数组。但是列表理解的强大之处在于使用以下语法动态创建的数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1469174|squares+=+[x**2+for+x+in+range(10)]|code-block|syntax|javascript|1469175|下面是Ruby中的一个类比(在这个主题中，AFAIC是唯一合适的答案)：|1469176|a+=+Array.new(4).map{rand(2**49..2**50)}+|1469177|在上面的例子中，我创建了一个随机整数数组，但是这个块可以包含任何东西。但这将是一个Ruby列表的理解。|1469178|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

There seems to be some confusion amongst Ruby programmers in this thread concerning what list comprehension is. Every single response assumes some preexisting array to transform. But list comprehension's power lies in an array created on the fly with the following syntax:

<pre><code>squares = [x**2 for x in range(10)]
</code></pre>

The following would be an analog in Ruby (the only adequate answer in this thread, AFAIC):

<pre><code>a = Array.new(4).map{rand(2**49..2**50)} 
</code></pre>

In the above case, I'm creating an array of random integers, but the block could contain anything. But this would be a Ruby list comprehension.

blocks|key|1469257|text|我刚刚将comprehend+gem发布到RubyGems，它允许您这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1469258|require+'comprehend'

some_array.comprehend{+%7Cx%7C+x+*+3+if+x+%25+2+==+0+}|code-block|syntax|javascript|1469259|它是用C语言编写的；数组只被遍历一次。|1469260|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/mdsol-share/comprehend^0|4|E|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

I've just published the <a href="https://github.com/mdsol-share/comprehend">comprehend gem</a> to RubyGems, which lets you do this:

<pre><code>require 'comprehend'

some_array.comprehend{ |x| x * 3 if x % 2 == 0 }
</code></pre>

It's written in C; the array is only traversed once.

blocks|key|1684538|text|如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1684539|def+lazy(collection,+&blk)
+++collection.map{%7Cx%7C+blk.call(x)}.compact
end|code-block|syntax|javascript|1684540|就叫它：|1684541|lazy+(1..6){%7Cx%7C+x+*+3+if+x.even?}|1684542|它返回：|1684543|=>+[6,+12,+18]|1684544|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Something like this:

<pre><code>def lazy(collection, &amp;blk)
 collection.map{|x| blk.call(x)}.compact
end
</code></pre>

Call it:

<pre><code>lazy (1..6){|x| x * 3 if x.even?}
</code></pre>

Which returns:

<pre><code>=&gt; [6, 12, 18]
</code></pre>

blocks|key|1684631|text|Enumerable有一个grep方法，它的第一个参数可以是谓词proc，第二个可选参数是一个映射函数；因此，下面的方法是有效的：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1684632|some_array.grep(proc+{%7Cx%7C+x+%25+2+==+0})+{%7Cx%7C+x*3}|code-block|syntax|javascript|1684633|这不像其他几个建议那样具有可读性(我喜欢anoiaque的simple+select.map或histocrat的comprehend+)，但它的优点是它已经是标准库的一部分，是单遍的，不涉及创建临时中间数组，并且不需要像compact-using建议中使用的nil那样的越界值。|1684634|entityMap^0|D|4|0|0|10|A|33|7|3M|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|N|$]]

Enumerable has a <code>grep</code> method whose first argument can be a predicate proc, and whose optional second argument is a mapping function; so the following works:

<pre><code>some_array.grep(proc {|x| x % 2 == 0}) {|x| x*3}
</code></pre>

This isn't as readable as a couple of other suggestions (I like anoiaque's simple <code>select.map</code> or histocrat's comprehend gem), but its strengths are that it's already part of the standard library, and is single-pass and doesn't involve creating temporary intermediate arrays, and doesn't require an out-of-bounds value like <code>nil</code> used in the <code>compact</code>-using suggestions.

blocks|key|1469421|text|另一种解决方案，但可能不是最好的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1469422|some_array.flat_map+{%7Cx%7C+x+%25+2+==+0+?+[x+*+3]+:+[]+}|code-block|syntax|javascript|1469423|或|1469424|some_array.each_with_object([])+{%7Cx,+list%7C+x+%25+2+==+0+?+list.push(x+*+3)+:+nil+}|1469425|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Another solution but perhaps not the best one

<pre><code>some_array.flat_map {|x| x % 2 == 0 ? [x * 3] : [] }
</code></pre>

or

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

blocks|key|1684756|text|这是解决这个问题的一种方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1684757|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])+%2B+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])+%2B+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])+%2B+x.split[3].length,+"+do+$*+<<+#{y}")
++++x.insert(x.length,+"end;+$*")
++++eval(x)
++++$*)
++else
++++eval(x.split[3]).to_a
++end
end+|code-block|syntax|javascript|1684758|所以基本上我们将一个字符串转换成正确的ruby语法进行循环，然后我们可以在字符串中使用python语法来做：|1684759|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]|1684760|或者，如果你不喜欢字符串的外观，或者不得不使用lambda，我们可以放弃镜像python语法的尝试，而是这样做：|1684761|S+=+[for+x+in+0...9+do+$*+<<+x*2+if+x.even?+end,+$*][1]
#+[0,+4,+8,+12,+16]|1684762|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This is one way to approach this:

<pre class="lang-rb prettyprint-override"><code>c = -&gt; x do $*.clear 
 if x['if'] &amp;&amp; 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 $* &lt;&lt; #{y}")
 x.insert(x.length, "end; $*")
 eval(x)
 $*)
 elsif x['if'] &amp;&amp; x[0] == 'f'
 (x.insert(x.index(x.split[3]) + x.split[3].length, " do $* &lt;&lt; x")
 x.insert(x.length, "end; $*")
 eval(x)
 $*)
 elsif !x['if'] &amp;&amp; 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 $* &lt;&lt; #{y}")
 x.insert(x.length, "end; $*")
 eval(x)
 $*)
 else
 eval(x.split[3]).to_a
 end
end 
</code></pre>

so basically we are converting a string to proper ruby syntax for loop
then we can use python syntax in a string to do:

<pre><code>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]
</code></pre>

or if you don't like the way the string looks or having to use a lambda we could forego the attempt to mirror python syntax and do something like this:

<pre><code>S = [for x in 0...9 do $* &lt;&lt; x*2 if x.even? end, $*][1]
# [0, 4, 8, 12, 16]
</code></pre>

blocks|key|1469598|text|https://rubygems.org/gems/ruby_list_comprehension|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1469599|我的Ruby列表理解gem的无耻插件，允许惯用的Ruby列表理解|1469600|$l[for+x+in+1..10+do+x+%2B+2+end]+#=>+[3,+4,+5+...]|code-block|syntax|javascript|1469601|entityMap|0|LINK|mutability|MUTABLE|url^0|0|1D|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|W|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|4]]]]

<a href="https://rubygems.org/gems/ruby_list_comprehension" rel="nofollow noreferrer">https://rubygems.org/gems/ruby_list_comprehension</a>
shameless plug for my Ruby List Comprehension gem to allow idiomatic Ruby list comprehensions
<pre><code>$l[for x in 1..10 do x + 2 end] #=&gt; [3, 4, 5 ...]
</code></pre>

blocks|key|1684901|text|Ruby2.7引入了filter_map，它很大程度上实现了你想要的(map+%2B+compact)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1684902|some_array.filter_map+{+%7Cx%7C+x+*+3+if+x+%25+2+==+0+}|code-block|syntax|javascript|1684903|你可以阅读更多关于它的here。|1684904|entityMap|0|LINK|mutability|MUTABLE|url|https://blog.saeloun.com/2019/05/25/ruby-2-7-enumerable-filter-map.html^0|A|A|0|0|B|4|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

Ruby 2.7 introduced <code>filter_map</code> which pretty much achieves what you want (map + compact):
<pre class="lang-rb prettyprint-override"><code>some_array.filter_map { |x| x * 3 if x % 2 == 0 }
</code></pre>
You can read more about it <a href="https://blog.saeloun.com/2019/05/25/ruby-2-7-enumerable-filter-map.html" rel="nofollow noreferrer">here</a>.

To do the equivalent of Python list comprehensions, I'm doing the following:

<pre><code>some_array.select{|x| x % 2 == 0 }.collect{|x| x * 3}
</code></pre>

Is there a better way to do this...perhaps with one method call?

List comprehension in Ruby

为了实现Python列表理解的等价物，我执行以下操作：some_array.select{|x| x % 2 == 0 }.collect{|x| x * 3}有没有更好的方法用一个方法调用来做this...perhaps？

问Ruby中的列表理解
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby中的列表理解EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby中的列表理解
EN