blocks|key|3223701|text|您可能需要考虑的其他Enumerable方法是each_slice或each_cons|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3223702|我不知道你希望它有多普遍，这里有一种方法|3223703|>>+(1..9).each_slice(3)+{%7Ca%7C+p+a.size>1?a[0..-2]:a}
[1,+2]
[4,+5]
[7,+8]
=>+nil
>>+(1..10).each_slice(3)+{%7Ca%7C+p+a.size>1?a[0..-2]:a}
[1,+2]
[4,+5]
[7,+8]
[10]|code-block|syntax|javascript|3223704|entityMap|0|LINK|mutability|MUTABLE|url|http://ruby-doc.org/core/classes/Enumerable.html|1|http://ruby-doc.org/core/classes/Enumerable.html#M001514|2|http://ruby-doc.org/core/classes/Enumerable.html#M001515^0|A|A|0|N|A|1|Y|9|2|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]|$A|10|B|11|1|12]|$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]|U|$5|N|O|P|C|$Q|V]]]]

Other <a href="http://ruby-doc.org/core/classes/Enumerable.html" rel="nofollow">Enumerable</a> methods you might want to consider is <a href="http://ruby-doc.org/core/classes/Enumerable.html#M001514" rel="nofollow">each_slice</a> or <a href="http://ruby-doc.org/core/classes/Enumerable.html#M001515" rel="nofollow">each_cons</a>

I don't know how general you want it to be, here's one way

<pre><code>&gt;&gt; (1..9).each_slice(3) {|a| p a.size&gt;1?a[0..-2]:a}
[1, 2]
[4, 5]
[7, 8]
=&gt; nil
&gt;&gt; (1..10).each_slice(3) {|a| p a.size&gt;1?a[0..-2]:a}
[1, 2]
[4, 5]
[7, 8]
[10]
</code></pre>

blocks|key|3436737|text|我试着打了一下高尔夫球，但仍然没有一种方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3436738|(1..9).chunk{%7Ci%7Ci%253==0}.reject{%7Csep,ans%7C+sep}.map{%7Csep,ans%7C+ans}|code-block|syntax|javascript|3436739|或更快：|3436740|(1..9).chunk{%7Ci%7Ci%253==0+%7C%7C+nil}.map{%7Csep,ans%7C+sep&&ans}.compact|3436741|而且，Enumerable#chunk看起来像是Ruby+1.9%2B，但它非常接近你想要的。|offset|length|style|CODE|3436742|例如，原始输出将为：|3436743|(1..9).chunk{+%7Ci%7Ci%253==0+}.to_a+++++++++++++++++++++++++++++++++++++++
=>+[[false,+[1,+2]],+[true,+[3]],+[false,+[4,+5]],+[true,+[6]],+[false,+[7,+8]],+[true,+[9]]]|3436744|(因为chunk提供的是枚举数而不是数组，所以to_a是为了让irb打印一些漂亮的东西)|3436745|3436746|编辑：请注意，上述优雅的解决方案比最快的实现慢2-3倍：|BOLD|3436747|module+Enumerable
++def+split_by
++++result+=+[a=[]]
++++each{+%7Co%7C+yield(o)+?+(result+<<+a=[])+:+(a+<<+o)+}
++++result.pop+if+a.empty?
++++result
++end
end|3436748|entityMap^0|0|0|0|0|3|G|0|0|0|3|5|N|4|0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|18|8|@$M|19|N|1A|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1D|8|@$M|1E|N|1F|O|P]|$M|1G|N|1H|O|P]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1J|8|@$M|1K|N|1L|O|Z]]|9|@]|A|$]]|$1|10|3|11|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|12|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|13|$]]

I tried golfing it a bit, still not a single method though:

<pre><code>(1..9).chunk{|i|i%3==0}.reject{|sep,ans| sep}.map{|sep,ans| ans}
</code></pre>

Or faster:

<pre><code>(1..9).chunk{|i|i%3==0 || nil}.map{|sep,ans| sep&amp;&amp;ans}.compact
</code></pre>

Also, <code>Enumerable#chunk</code> seems to be Ruby 1.9+, but it is very close to what you want.

For example, the raw output would be:

<pre><code>(1..9).chunk{ |i|i%3==0 }.to_a 
=&gt; [[false, [1, 2]], [true, [3]], [false, [4, 5]], [true, [6]], [false, [7, 8]], [true, [9]]]
</code></pre>

(The <code>to_a</code> is to make irb print something nice, since <code>chunk</code> gives you an enumerator rather than an Array) 

<hr>

Edit: Note that the above elegant solutions are 2-3x slower than the fastest implementation:

<pre class="lang-ruby prettyprint-override"><code>module Enumerable
 def split_by
 result = [a=[]]
 each{ |o| yield(o) ? (result &lt;&lt; a=[]) : (a &lt;&lt; o) }
 result.pop if a.empty?
 result
 end
end
</code></pre>

blocks|key|397819|text|以下是汇总答案的基准(我不会接受这个答案)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|397820|require+'benchmark'
a+=+*(1..5000);+N+=+1000
Benchmark.bmbm+do+%7Cx%7C
++%25w[+split_with_inject+split_with_inject_no_tap+split_with_each
++++++split_with_chunk+split_with_chunk2+split_with_chunk3+].each+do+%7Cmethod%7C
++++x.report(+method+){+N.times{+a.send(method){+%7Ci%7C+i%253==0+%7C%7C+i%255==0+}+}+}
++end
end
#=>++++++++++++++++++++++++++++++++user+++++system++++++total++++++++real
#=>+split_with_inject++++++++++1.857000+++0.015000+++1.872000+(++1.879188)
#=>+split_with_inject_no_tap+++1.357000+++0.000000+++1.357000+(++1.353135)
#=>+split_with_each++++++++++++1.123000+++0.000000+++1.123000+(++1.123113)
#=>+split_with_chunk+++++++++++3.962000+++0.000000+++3.962000+(++3.984398)
#=>+split_with_chunk2++++++++++3.682000+++0.000000+++3.682000+(++3.687369)
#=>+split_with_chunk3++++++++++2.278000+++0.000000+++2.278000+(++2.281228)|code-block|syntax|javascript|397821|正在测试的实现(在Ruby+1.9.2上)：|397822|class+Array
++def+split_with_inject
++++inject([[]])+do+%7Ca,v%7C
++++++a.tap{+yield(v)+?+(a+<<+[])+:+(a.last+<<+v)+}
++++end.tap{+%7Ca%7C+a.pop+if+a.last.empty?+}
++end

++def+split_with_inject_no_tap
++++result+=+inject([[]])+do+%7Ca,v%7C
++++++yield(v)+?+(a+<<+[])+:+(a.last+<<+v)
++++++a
++++end
++++result.pop+if+result.last.empty?
++++result
++end

++def+split_with_each
++++result+=+[a=[]]
++++each{+%7Co%7C+yield(o)+?+(result+<<+a=[])+:+(a+<<+o)+}
++++result.pop+if+a.empty?
++++result
++end

++def+split_with_chunk
++++chunk{+%7Co%7C+!!yield(o)+}.reject{+%7Cb,a%7C+b+}.map{+%7Cb,a%7C+a+}
++end

++def+split_with_chunk2
++++chunk{+%7Co%7C+!!yield(o)+}.map{+%7Cb,a%7C+b+?+nil+:+a+}.compact
++end

++def+split_with_chunk3
++++chunk{+%7Co%7C+yield(o)+%7C%7C+nil+}.map{+%7Cb,a%7C+b+&&+a+}.compact
++end
end|397823|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|$]]

Here are benchmarks aggregating the answers (I'll not be accepting this answer):

<pre><code>require 'benchmark'
a = *(1..5000); N = 1000
Benchmark.bmbm do |x|
 %w[ split_with_inject split_with_inject_no_tap split_with_each
 split_with_chunk split_with_chunk2 split_with_chunk3 ].each do |method|
 x.report( method ){ N.times{ a.send(method){ |i| i%3==0 || i%5==0 } } }
 end
end
#=&gt; user system total real
#=&gt; split_with_inject 1.857000 0.015000 1.872000 ( 1.879188)
#=&gt; split_with_inject_no_tap 1.357000 0.000000 1.357000 ( 1.353135)
#=&gt; split_with_each 1.123000 0.000000 1.123000 ( 1.123113)
#=&gt; split_with_chunk 3.962000 0.000000 3.962000 ( 3.984398)
#=&gt; split_with_chunk2 3.682000 0.000000 3.682000 ( 3.687369)
#=&gt; split_with_chunk3 2.278000 0.000000 2.278000 ( 2.281228)
</code></pre>

The implementations being tested (on Ruby 1.9.2):

<pre><code>class Array
 def split_with_inject
 inject([[]]) do |a,v|
 a.tap{ yield(v) ? (a &lt;&lt; []) : (a.last &lt;&lt; v) }
 end.tap{ |a| a.pop if a.last.empty? }
 end

 def split_with_inject_no_tap
 result = inject([[]]) do |a,v|
 yield(v) ? (a &lt;&lt; []) : (a.last &lt;&lt; v)
 a
 end
 result.pop if result.last.empty?
 result
 end

 def split_with_each
 result = [a=[]]
 each{ |o| yield(o) ? (result &lt;&lt; a=[]) : (a &lt;&lt; o) }
 result.pop if a.empty?
 result
 end

 def split_with_chunk
 chunk{ |o| !!yield(o) }.reject{ |b,a| b }.map{ |b,a| a }
 end

 def split_with_chunk2
 chunk{ |o| !!yield(o) }.map{ |b,a| b ? nil : a }.compact
 end

 def split_with_chunk3
 chunk{ |o| yield(o) || nil }.map{ |b,a| b &amp;&amp; a }.compact
 end
end
</code></pre>

blocks|key|3436794|text|下面是另一个(通过基准测试将其与最快的split_with_each+here+https://stackoverflow.com/a/4801483/410102进行比较)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3436795|require+'benchmark'

class+Array
++def+split_with_each
++++result+=+[a=[]]
++++each{+%7Co%7C+yield(o)+?+(result+<<+a=[])+:+(a+<<+o)+}
++++result.pop+if+a.empty?
++++result
++end

++def+split_with_each_2
++++u,+v+=+[],+[]
++++each{+%7Cx%7C+(yield+x)+?+(u+<<+x)+:+(v+<<+x)+}
++++[u,+v]
++end
end

a+=+*(1..5000);+N+=+1000
Benchmark.bmbm+do+%7Cx%7C
++%25w[+split_with_each+split_with_each_2+].each+do+%7Cmethod%7C
++++x.report(+method+){+N.times{+a.send(method){+%7Ci%7C+i%253==0+%7C%7C+i%255==0+}+}+}
++end
end

++++++++++++++++++++++++user+++++system++++++total++++++++real
split_with_each+++++2.730000+++0.000000+++2.730000+(++2.742135)
split_with_each_2+++2.270000+++0.040000+++2.310000+(++2.309600)|code-block|syntax|javascript|3436796|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/4801483/410102^0|J|F|14|16|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]]]]

here is another one (with a benchmark comparing it to the fastest <code>split_with_each</code> here <a href="https://stackoverflow.com/a/4801483/410102">https://stackoverflow.com/a/4801483/410102</a>):

<pre><code>require 'benchmark'

class Array
 def split_with_each
 result = [a=[]]
 each{ |o| yield(o) ? (result &lt;&lt; a=[]) : (a &lt;&lt; o) }
 result.pop if a.empty?
 result
 end

 def split_with_each_2
 u, v = [], []
 each{ |x| (yield x) ? (u &lt;&lt; x) : (v &lt;&lt; x) }
 [u, v]
 end
end

a = *(1..5000); N = 1000
Benchmark.bmbm do |x|
 %w[ split_with_each split_with_each_2 ].each do |method|
 x.report( method ){ N.times{ a.send(method){ |i| i%3==0 || i%5==0 } } }
 end
end

 user system total real
split_with_each 2.730000 0.000000 2.730000 ( 2.742135)
split_with_each_2 2.270000 0.040000 2.310000 ( 2.309600)
</code></pre>

blocks|key|398561|text|有时候，partition是一种很好的方式来做这样的事情：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|398562|(1..6).partition+{+%7Cv%7C+v.even?+}+
#=>+[[2,+4,+6],+[1,+3,+5]]|code-block|syntax|javascript|398563|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ruby-doc.org/core-2.0.0/Enumerable.html#method-i-partition^0|4|9|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Sometimes <a href="http://www.ruby-doc.org/core-2.0.0/Enumerable.html#method-i-partition" rel="noreferrer">partition</a> is a good way to do things like that:

<pre><code>(1..6).partition { |v| v.even? } 
#=&gt; [[2, 4, 6], [1, 3, 5]]
</code></pre>

I was looking for an Array equivalent <code>String#split</code> in Ruby Core, and was surprised to find that it did not exist. Is there a more elegant way than the following to split an array into sub-arrays based on a value?

<pre><code>class Array
 def split( split_on=nil )
 inject([[]]) do |a,v|
 a.tap{
 if block_given? ? yield(v) : v==split_on
 a &lt;&lt; []
 else
 a.last &lt;&lt; v
 end
 }
 end.tap{ |a| a.pop if a.last.empty? }
 end
end

p (1..9 ).to_a.split{ |i| i%3==0 },
 (1..10).to_a.split{ |i| i%3==0 }
#=&gt; [[1, 2], [4, 5], [7, 8]]
#=&gt; [[1, 2], [4, 5], [7, 8], [10]]
</code></pre>

Edit: For those interested, the "real-world" problem which sparked this request can be seen in <a href="https://stackoverflow.com/questions/4798976/nokogiri-need-to-turn-markup-partitioned-by-hr-into-divs/4801341#4801341">this answer</a>, where I've used @fd's answer below for the implementation.

Split array into sub-arrays based on value

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在寻找Ruby Core中与数组等效的String#split，并惊讶地发现它并不存在。有没有比下面更好的方法来根据值将一个数组分成多个子数组？class Array  def split( split_on=nil )    inject([[]]) do |a,v|      a.tap{        if ...

问根据值将数组拆分为子数组
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问根据值将数组拆分为子数组EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问根据值将数组拆分为子数组
EN