blocks|key|301891|text|不能，但你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|301892|lines.map+{+%7Cline%7C+do_some_action+if+check_some_property++}.reject(&:nil?)|code-block|syntax|javascript|301893|或者更好：|301894|lines.inject([])+{+%7Call,+line%7C+all+<<+line+if+check_some_property;+all+}|301895|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|$]]

No, but you can do it like this:

<pre><code>lines.map { |line| do_some_action if check_some_property }.reject(&amp;:nil?)
</code></pre>

Or even better:

<pre><code>lines.inject([]) { |all, line| all &lt;&lt; line if check_some_property; all }
</code></pre>

blocks|key|303957|text|我通常将map和compact与我的选择标准一起使用，作为后缀if。compact摆脱了nils。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|303958|jruby-1.5.0+>+[1,1,1,2,3,4].map{%7Cn%7C+n*3+if+n==1}++++
+=>+[3,+3,+3,+nil,+nil,+nil]+


jruby-1.5.0+>+[1,1,1,2,3,4].map{%7Cn%7C+n*3+if+n==1}.compact
+=>+[3,+3,+3]+|code-block|syntax|javascript|303959|entityMap^0|4|3|8|7|V|2|Y|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|L|$]]

I usually use <code>map</code> and <code>compact</code> together along with my selection criteria as a postfix <code>if</code>. <code>compact</code> gets rid of the nils.

<pre><code>jruby-1.5.0 &gt; [1,1,1,2,3,4].map{|n| n*3 if n==1} 
 =&gt; [3, 3, 3, nil, nil, nil] 


jruby-1.5.0 &gt; [1,1,1,2,3,4].map{|n| n*3 if n==1}.compact
 =&gt; [3, 3, 3] 
</code></pre>

blocks|key|301973|text|我不确定有没有。添加了select和map的Enumerable+module却没有显示。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|301974|您需要将两个代码块传递给select_and_transform方法，这有点不直观。|301975|显然，您可以将它们链接在一起，这更具可读性：|301976|transformed_list+=+lines.select{%7Cline%7C+...}.map{%7Cline%7C+...+}|code-block|syntax|javascript|301977|entityMap|0|LINK|mutability|MUTABLE|url|http://ruby-doc.org/core/classes/Enumerable.html^0|B|6|I|3|M|H|0|0|C|K|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|17|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|18|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

I'm not sure there is one. The <a href="http://ruby-doc.org/core/classes/Enumerable.html" rel="nofollow noreferrer">Enumerable module</a>, which adds <code>select</code> and <code>map</code>, doesn't show one. 

You'd be required to pass in two blocks to the <code>select_and_transform</code> method, which would be a bit unintuitive IMHO.

Obviously, you could just chain them together, which is more readable:

<pre><code>transformed_list = lines.select{|line| ...}.map{|line| ... }
</code></pre>

blocks|key|298972|text|def+example
++@lines.select+{%7Cline%7C+...+}.map+{%7Cline%7C+...+}.uniq.sort
end|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|298973|在Ruby+1.9和1.8.7中，您还可以通过简单地不向迭代器传递块来链接和包装迭代器：|unstyled|298974|enum.select.map+{%7Cbla%7C+...+}|298975|但在这种情况下这是不可能的，因为select和map的块返回值的类型不匹配。对于这样的东西，它更有意义：|offset|length|style|CODE|298976|enum.inject.with_index+{%7C(acc,+el),+idx%7C+...+}|298977|AFAICS，你能做的最多的就是第一个例子。|298978|下面是一个小示例：|298979|%25w[a+b+1+2+c+d].map.select+{%7Ce%7C+if+/[0-9]/+=~+e+then+false+else+e.upcase+end+}
#+=>+["a",+"b",+"c",+"d"]

%25w[a+b+1+2+c+d].select.map+{%7Ce%7C+if+/[0-9]/+=~+e+then+false+else+e.upcase+end+}
#+=>+["A",+"B",+false,+false,+"C",+"D"]|298980|但你真正想要的是["A",+"B",+"C",+"D"]。|298981|entityMap^0|0|0|0|G|6|N|3|0|0|0|0|0|8|K|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|13|8|@$K|14|L|15|M|N]|$K|16|L|17|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$B|C]]|$1|Q|3|R|5|F|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$B|C]]|$1|W|3|X|5|F|7|1C|8|@$K|1D|L|1E|M|N]]|9|@]|A|$]]|$1|Y|3|-4|5|F|7|1F|8|@]|9|@]|A|$]]]|Z|$]]

<pre><code>def example
 @lines.select {|line| ... }.map {|line| ... }.uniq.sort
end
</code></pre>

In Ruby 1.9 and 1.8.7, you can also chain and wrap iterators by simply not passing a block to them:

<pre><code>enum.select.map {|bla| ... }
</code></pre>

But it's not really possible in this case, since the types of the block return values of <code>select</code> and <code>map</code> don't match up. It makes more sense for something like this:

<pre><code>enum.inject.with_index {|(acc, el), idx| ... }
</code></pre>

AFAICS, the best you can do is the first example.

Here's a small example:

<pre><code>%w[a b 1 2 c d].map.select {|e| if /[0-9]/ =~ e then false else e.upcase end }
# =&gt; ["a", "b", "c", "d"]

%w[a b 1 2 c d].select.map {|e| if /[0-9]/ =~ e then false else e.upcase end }
# =&gt; ["A", "B", false, false, "C", "D"]
</code></pre>

But what you really want is <code>["A", "B", "C", "D"]</code>.

blocks|key|298986|text|为此，您可以使用reduce，它只需要一次传递：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|298987|[1,1,1,2,3,4].reduce([])+{+%7Ca,+n%7C+a.push(n*3)+if+n==1;+a+}
=>+[3,+3,+3]+|code-block|syntax|javascript|298988|换句话说，将状态初始化为您想要的状态(在我们的例子中，是一个要填充的空列表：[])，然后始终确保返回这个值，并对原始列表中的每个元素进行修改(在我们的例子中，修改后的元素被推入列表)。|298989|这是最有效的，因为它只通过一次遍历列表(map+%2B+select或compact需要两次遍历)。|298990|在您的案例中：|298991|def+example
++results+=+@lines.reduce([])+do+%7Clines,+line%7C
++++lines.push(+...(line)+)+if+...
++++lines
++end
++return+results.uniq.sort
end|298992|entityMap^0|8|6|0|0|12|2|0|K|3|Q|6|X|7|0|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|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|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|O|3|P|5|6|7|18|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|T|$]]

You can use <code>reduce</code> for this, which requires only one pass:

<pre><code>[1,1,1,2,3,4].reduce([]) { |a, n| a.push(n*3) if n==1; a }
=&gt; [3, 3, 3] 
</code></pre>

In other words, initialize the state to be what you want (in our case, an empty list to fill: <code>[]</code>), then always make sure to return this value with modifications for each element in the original list (in our case, the modified element pushed to the list).

This is the most efficient since it only loops over the list with one pass (<code>map</code> + <code>select</code> or <code>compact</code> requires two passes).

In your case:

<pre><code>def example
 results = @lines.reduce([]) do |lines, line|
 lines.push( ...(line) ) if ...
 lines
 end
 return results.uniq.sort
end
</code></pre>

blocks|key|299010|text|我认为这种方式更具可读性，因为它将过滤条件和映射值分开，同时保持操作之间的关联：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|299011|results+=+@lines.select+{+%7Cline%7C
++line.should_include?
}.map+do+%7Cline%7C
++line.value_to_map
end|code-block|syntax|javascript|299012|并且，在您的特定情况下，将result变量一起删除：|offset|length|style|CODE|299013|def+example
++@lines.select+{+%7Cline%7C
++++line.should_include?
++}.map+{+%7Cline%7C
++++line.value_to_map
++}.uniq.sort
end|299014|entityMap^0|0|0|D|6|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|@$I|T|J|U|K|L]]|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|$]]

I think that this way is more readable, because splits the filter conditions and mapped value while remaining clear that the actions are connected:

<pre><code>results = @lines.select { |line|
 line.should_include?
}.map do |line|
 line.value_to_map
end
</code></pre>

And, in your specific case, eliminate the <code>result</code> variable all together:

<pre><code>def example
 @lines.select { |line|
 line.should_include?
 }.map { |line|
 line.value_to_map
 }.uniq.sort
end
</code></pre>

blocks|key|299016|text|如果您有一个可以使用case运算符(===)的select，那么grep是一个很好的选择：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|299017|p+[1,2,'not_a_number',3].grep(Integer){%7Cx%7C+-x+}+#=>+[-1,+-2,+-3]

p+['1','2','not_a_number','3'].grep(/\D/,+&:upcase)+#=>+["NOT_A_NUMBER"]|code-block|syntax|javascript|299018|如果我们需要更复杂的逻辑，我们可以创建lambda：|299019|my_favourite_numbers+=+[1,4,6]

is_a_favourite_number+=+->+x+{+my_favourite_numbers.include?+x+}

make_awesome+=+->+x+{+"***#{x}***"+}

my_data+=+[1,2,3,4]

p+my_data.grep(is_a_favourite_number,+&make_awesome)+#=>+["***1***",+"***4***"]|299020|entityMap^0|A|4|I|3|N|6|W|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|P|$]]

If you have a <code>select</code> that can use the <code>case</code> operator (<code>===</code>), <code>grep</code> is a good alternative:

<pre><code>p [1,2,'not_a_number',3].grep(Integer){|x| -x } #=&gt; [-1, -2, -3]

p ['1','2','not_a_number','3'].grep(/\D/, &amp;:upcase) #=&gt; ["NOT_A_NUMBER"]
</code></pre>

If we need more complex logic we can create lambdas:

<pre><code>my_favourite_numbers = [1,4,6]

is_a_favourite_number = -&gt; x { my_favourite_numbers.include? x }

make_awesome = -&gt; x { "***#{x}***" }

my_data = [1,2,3,4]

p my_data.grep(is_a_favourite_number, &amp;make_awesome) #=&gt; ["***1***", "***4***"]
</code></pre>

blocks|key|302037|text|下面是一个例子。它与你的问题不同，但可能是你想要的，或者可以为你的解决方案提供线索：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|302038|def+example
++lines.each+do+%7Cx%7C
++++new_value+=+do_transform(x)
++++if+new_value+==+some_thing
++++++return+new_value++++#+here+jump+out+example+method+directly.
++++else
++++++next++++++++++++++++#+continue+next+iterate.
++++end
++end
end|code-block|syntax|javascript|302039|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|$]]

Here is a example. It is not the same as your problem, but may be what you want, or can give a clue to your solution:

<pre><code>def example
 lines.each do |x|
 new_value = do_transform(x)
 if new_value == some_thing
 return new_value # here jump out example method directly.
 else
 next # continue next iterate.
 end
 end
end
</code></pre>

blocks|key|302054|text|另一种不同的方法是使用新的(相对于这个问题)+Enumerator::Lazy|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|302055|def+example
++@lines.lazy
++++++++.select+{+%7Cline%7C+line.property+==+requirement+}
++++++++.map++++{+%7Cline%7C+transforming_method(line)+}
++++++++.uniq
++++++++.sort
end|code-block|syntax|javascript|302056|.lazy方法返回一个惰性枚举器。在惰性枚举器上调用.select或.map会返回另一个惰性枚举器。只有当你调用.uniq时，它才会强制枚举器并返回一个数组。因此，有效的做法是将.select和.map调用合并为一个-您只需在@lines上迭代一次，即可同时执行.select和.map。|302057|我的直觉是Adam的reduce方法会更快一点，但我认为这更具可读性。|302058|302059|这样做的主要结果是不会为后续的每个方法调用创建中间数组对象。在正常的@lines.select.map情况下，select返回一个数组，该数组随后被map修改，再次返回一个数组。相比之下，惰性求值只创建一次数组。当您的初始集合对象很大时，这很有用。它还允许您使用无限枚举器-例如random_number_generator.lazy.select(&:odd?).take(10)。|302060|entityMap^0|N|G|0|0|0|5|Q|7|Y|4|1K|5|2H|7|2P|4|35|6|3N|7|3V|4|0|A|6|0|0|Y|H|1J|6|22|3|3V|1G|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|W|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1G|8|@$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1K|8|@$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]]|S|$]]

Another different way of approaching this is using the new (relative to this question) <code>Enumerator::Lazy</code>:

<pre><code>def example
 @lines.lazy
 .select { |line| line.property == requirement }
 .map { |line| transforming_method(line) }
 .uniq
 .sort
end
</code></pre>

The <code>.lazy</code> method returns a lazy enumerator. Calling <code>.select</code> or <code>.map</code> on a lazy enumerator returns another lazy enumerator. Only once you call <code>.uniq</code> does it actually force the enumerator and return an array. So what effectively happens is your <code>.select</code> and <code>.map</code> calls are combined into one - you only iterate over <code>@lines</code> once to do both <code>.select</code> and <code>.map</code>.

My instinct is that Adam's <code>reduce</code> method will be a little faster, but I think this is far more readable.

<hr>

The primary consequence of this is that no intermediate array objects are created for each subsequent method call. In a normal <code>@lines.select.map</code> situation, <code>select</code> returns an array which is then modified by <code>map</code>, again returning an array. By comparison, the lazy evaluation only creates an array once. This is useful when your initial collection object is large. It also empowers you to work with infinite enumerators - e.g. <code>random_number_generator.lazy.select(&amp;:odd?).take(10)</code>.

blocks|key|3030986|text|答案很简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3030987|如果您有n条记录，并且希望根据条件执行select和map，那么|offset|length|style|CODE|3030988|records.map+{+%7Crecord%7C+record.attribute+if+condition+}.compact|code-block|syntax|javascript|3030989|在这里，属性是你想要的任何记录和条件，你可以放置任何检查。|3030990|compact是刷新从if条件中产生的不必要的nil。|3030991|entityMap^0|0|J|6|Q|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]|$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

Simple Answer:

If you have n records, and you want to <code>select</code> and <code>map</code> based on condition then

<pre><code>records.map { |record| record.attribute if condition }.compact
</code></pre>

Here, attribute is whatever you want from the record and condition you can put any check.

compact is to flush the unnecessary nil's which came out of that if condition

blocks|key|3245139|text|您应该尝试使用我的库Rearmed+Ruby，我在其中添加了方法Enumerable#select_map。下面是一个例子：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3245140|items+=+[{version:+"1.1"},+{version:+nil},+{version:+false}]

items.select_map{%7Cx%7C+x[:version]}+#=>+[{version:+"1.1"}]
#+or+without+enumerable+monkey+patch
Rearmed.select_map(items){%7Cx%7C+x[:version]}|code-block|syntax|javascript|3245141|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/westonganger/rearmed-rb^0|W|L|A|C|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

You should try using my library <a href="https://github.com/westonganger/rearmed-rb" rel="nofollow noreferrer">Rearmed Ruby</a> in which I have added the method <code>Enumerable#select_map</code>. Heres an example:

<pre><code>items = [{version: "1.1"}, {version: nil}, {version: false}]

items.select_map{|x| x[:version]} #=&gt; [{version: "1.1"}]
# or without enumerable monkey patch
Rearmed.select_map(items){|x| x[:version]}
</code></pre>

blocks|key|3031027|text|如果不想创建两个不同的数组，可以使用compact!，但要小心。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3031028|array+=+[1,1,1,2,3,4]
new_array+=+map{%7Cn%7C+n*3+if+n==1}
new_array.compact!|code-block|syntax|javascript|3031029|有趣的是，compact!就地删除了nil。如果有变化，compact!的返回值是相同的数组；如果没有nil，则返回值为nil。|3031030|array+=+[1,1,1,2,3,4]
new_array+=+map{%7Cn%7C+n*3+if+n==1}.tap+{+%7Carray%7C+array.compact!+}|3031031|将会是一条直线。|3031032|entityMap^0|I|8|0|0|5|8|S|8|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|R|$]]

If you want to not create two different arrays, you can use <code>compact!</code> but be careful about it.

<pre><code>array = [1,1,1,2,3,4]
new_array = map{|n| n*3 if n==1}
new_array.compact!
</code></pre>

Interestingly, <code>compact!</code> does an in place removal of nil. The return value of <code>compact!</code> is the same array if there were changes but nil if there were no nils.

<pre><code>array = [1,1,1,2,3,4]
new_array = map{|n| n*3 if n==1}.tap { |array| array.compact! }
</code></pre>

Would be a one liner.

blocks|key|3245196|text|您的版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3245197|def+example
++matchingLines+=+@lines.select{+%7Cline%7C+...+}
++results+=+matchingLines.map{+%7Cline%7C+...+}
++return+results.uniq.sort
end|code-block|syntax|javascript|3245198|我的版本：|3245199|def+example
++results+=+{}
++@lines.each{+%7Cline%7C+results[line]+=+true+if+...+}
++return+results.keys.sort
end|3245200|这将进行1次迭代(除了排序)，并且具有保持唯一性的额外好处(如果您不关心uniq，那么只需将结果作为数组和results.push(line)+if+...|offset|length|style|CODE|3245201|entityMap^0|0|0|0|0|1H|P|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Your version:

<pre><code>def example
 matchingLines = @lines.select{ |line| ... }
 results = matchingLines.map{ |line| ... }
 return results.uniq.sort
end
</code></pre>

My version:

<pre><code>def example
 results = {}
 @lines.each{ |line| results[line] = true if ... }
 return results.keys.sort
end
</code></pre>

This will do 1 iteration (except the sort), and has the added bonus of keeping uniqueness (if you don't care about uniq, then just make results an array and <code>results.push(line) if ...</code>

blocks|key|3031107|text|Ruby+2.7%2B|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3031108|现在有了！|3031109|Ruby2.7正是为了这个目的引入了filter_map。它是惯用的，性能很好，我希望它很快就会成为常态。|CODE|3031110|例如：|3031111|numbers+=+[1,+2,+5,+8,+10,+13]
enum.filter_map+{+%7Ci%7C+i+*+2+if+i.even?+}
#+=>+[4,+16,+20]|code-block|syntax|javascript|3031112|这是一个good+read+on+the+subject。|3031113|希望这对某些人有用！|3031114|entityMap|0|LINK|mutability|MUTABLE|url|https://blog.saeloun.com/2019/05/25/ruby-2-7-enumerable-filter-map.html^0|0|9|0|0|I|A|0|0|0|4|O|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|16|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|17|8|@$9|18|A|19|B|J]]|D|@]|E|$]]|$1|K|3|L|5|6|7|1A|8|@]|D|@]|E|$]]|$1|M|3|N|5|O|7|1B|8|@]|D|@]|E|$P|Q]]|$1|R|3|S|5|6|7|1C|8|@]|D|@$9|1D|A|1E|1|1F]]|E|$]]|$1|T|3|U|5|6|7|1G|8|@]|D|@]|E|$]]|$1|V|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|W|$X|$5|Y|Z|10|E|$11|12]]]]

Ruby 2.7+

There is now!

Ruby 2.7 is introducing <code>filter_map</code> for this exact purpose. It's idiomatic and performant, and I'd expect it to become the norm very soon.

For example:

<pre><code>numbers = [1, 2, 5, 8, 10, 13]
enum.filter_map { |i| i * 2 if i.even? }
# =&gt; [4, 16, 20]
</code></pre>

Here's a <a href="https://blog.saeloun.com/2019/05/25/ruby-2-7-enumerable-filter-map.html" rel="noreferrer">good read on the subject</a>.

Hope that's useful to someone!

I have a Ruby array containing some string values. I need to:

<ol>
<li>Find all elements that match some predicate</li>
<li>Run the matching elements through a transformation</li>
<li>Return the results as an array</li>
</ol>

Right now my solution looks like this:

<pre><code>def example
 matchingLines = @lines.select{ |line| ... }
 results = matchingLines.map{ |line| ... }
 return results.uniq.sort
end
</code></pre>

Is there an Array or Enumerable method that combines select and map into a single logical statement?

In Ruby, is there an Array method that combines 'select' and 'map'?

我有一个包含一些字符串值的Ruby数组。我需要：查找与某个谓词匹配的所有元素通过transformationReturn  as a transformationReturn运行匹配的元素现在我的解决方案是这样的：def example  matchingLines = @lines.select{ |line| .....

问在Ruby中，有组合'select‘和'map’的Array方法吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中，有组合'select‘和'map’的Array方法吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中，有组合'select‘和'map’的Array方法吗？
EN