blocks|key|345302|text|你脑海中还有其他的限制吗？否则我会非常想做一些简单的事情，比如|type|unstyled|depth|inlineStyleRanges|entityRanges|data|345303|[0..10].each+{
+++str[(i*w),w]
}|code-block|syntax|javascript|345304|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|$]]

Are there some other constraints you have in mind? Otherwise I'd be awfully tempted to do something simple like

<pre><code>[0..10].each {
 str[(i*w),w]
}
</code></pre>

blocks|key|3331381|text|test.split(/(...)/).reject+{%7Cv%7C+v.empty?}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3331382|reject是必需的，因为否则它会包含集合之间的空格。我的regex-fu还不能完全解决这个问题。|unstyled|3331383|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>test.split(/(...)/).reject {|v| v.empty?}
</code></pre>

The reject is necessary because it otherwise includes the blank space between sets. My regex-fu isn't quite up to seeing how to fix that right off the top of my head.

blocks|key|345328|text|使用String#scan|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|345329|>>+'abcdefghijklmnopqrstuvwxyz'.scan(/.{4}/)
=>+["abcd",+"efgh",+"ijkl",+"mnop",+"qrst",+"uvwx"]
>>+'abcdefghijklmnopqrstuvwxyz'.scan(/.{1,4}/)
=>+["abcd",+"efgh",+"ijkl",+"mnop",+"qrst",+"uvwx",+"yz"]
>>+'abcdefghijklmnopqrstuvwxyz'.scan(/.{1,3}/)
=>+["abc",+"def",+"ghi",+"jkl",+"mno",+"pqr",+"stu",+"vwx",+"yz"]|code-block|syntax|javascript|345330|entityMap^0|2|B|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Use <code>String#scan</code>:

<pre><code>&gt;&gt; 'abcdefghijklmnopqrstuvwxyz'.scan(/.{4}/)
=&gt; ["abcd", "efgh", "ijkl", "mnop", "qrst", "uvwx"]
&gt;&gt; 'abcdefghijklmnopqrstuvwxyz'.scan(/.{1,4}/)
=&gt; ["abcd", "efgh", "ijkl", "mnop", "qrst", "uvwx", "yz"]
&gt;&gt; 'abcdefghijklmnopqrstuvwxyz'.scan(/.{1,3}/)
=&gt; ["abc", "def", "ghi", "jkl", "mno", "pqr", "stu", "vwx", "yz"]
</code></pre>

blocks|key|3118630|text|这是另一种方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3118631|"abcdefghijklmnopqrstuvwxyz".chars.to_a.each_slice(3).to_a.map+{%7Cs%7C+s.to_s+}|code-block|syntax|javascript|3118632|=>+"abc"，"def"，"ghi"，"jkl"，"mno"，"pqr"，"stu"，"vwx"，"yz“|3118633|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|$]]

Here is another way to do it:

<pre><code>"abcdefghijklmnopqrstuvwxyz".chars.to_a.each_slice(3).to_a.map {|s| s.to_s }
</code></pre>

=> ["abc", "def", "ghi", "jkl", "mno", "pqr", "stu", "vwx", "yz"]

blocks|key|345341|text|我认为这是最有效的解决方案，如果你知道你的字符串是区块大小的倍数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|345342|def+chunk(string,+size)
++++(string.length+/+size).times.collect+{+%7Ci%7C+string[i+*+size,+size]+}
end|code-block|syntax|javascript|345343|而对于部件|345344|def+parts(string,+count)
++++size+=+string.length+/+count
++++count.times.collect+{+%7Ci%7C+string[i+*+size,+size]+}
end|345345|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|$]]

I think this is the most efficient solution if you know your string is a multiple of chunk size

<pre><code>def chunk(string, size)
 (string.length / size).times.collect { |i| string[i * size, size] }
end
</code></pre>

and for parts

<pre><code>def parts(string, count)
 size = string.length / count
 count.times.collect { |i| string[i * size, size] }
end
</code></pre>

blocks|key|347978|text|这里是另一种稍微不同的情况的解决方案，当处理大字符串时，不需要一次存储所有的块。通过这种方式，它一次存储单个块，并且执行速度比切分字符串快得多：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|347979|io+=+StringIO.new(string)
until+io.eof?
++chunk+=+io.read(chunk_size)
++do_something(chunk)
end|code-block|syntax|javascript|347980|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 another one solution for slightly different case, when processing large strings and there is no need to store all chunks at a time. In this way it stores single chunk at a time and performs much faster than slicing strings:
<pre><code>io = StringIO.new(string)
until io.eof?
 chunk = io.read(chunk_size)
 do_something(chunk)
end
</code></pre>

blocks|key|3331463|text|一种更好的解决方案，它考虑了字符串的最后一部分，它可能小于块大小：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3331464|def+chunk(inStr,+sz)++
++return+[inStr]+if+inStr.length+<+sz++
++m+=+inStr.length+%25+sz+#+this+is+the+last+part+of+the+string
++partial+=+(inStr.length+/+sz).times.collect+{+%7Ci%7C+inStr[i+*+sz,+sz]+}
++partial+<<+inStr[-m..-1]+if+(m+%25+sz+!=+0)+#+add+the+last+part+
++partial
end|code-block|syntax|javascript|3331465|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|$]]

A better solution which takes into account the last part of the string which could be less than the chunk size:

<pre><code>def chunk(inStr, sz) 
 return [inStr] if inStr.length &lt; sz 
 m = inStr.length % sz # this is the last part of the string
 partial = (inStr.length / sz).times.collect { |i| inStr[i * sz, sz] }
 partial &lt;&lt; inStr[-m..-1] if (m % sz != 0) # add the last part 
 partial
end
</code></pre>

blocks|key|345369|text|我做了一个小测试，将大约593MB的数据切成18991个32KB的片段。在我按ctrl%2BC之前，你的slice%2Bmap版本在100%25cpu下运行了至少15分钟。这个使用String#unpack的版本在3.6秒内完成：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|345370|def+chunk(string,+size)
++string.unpack("a#{size}"+*+(string.size/size.to_f).ceil)
end|code-block|syntax|javascript|345371|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|$]]

I made a little test that chops about 593MB data into 18991 32KB pieces.
Your slice+map version ran for at least 15 minutes using 100% CPU before I pressed ctrl+C. This version using String#unpack finished in 3.6 seconds:

<pre><code>def chunk(string, size)
 string.unpack("a#{size}" * (string.size/size.to_f).ceil)
end
</code></pre>

blocks|key|3118785|text|只是text.scan(/.{1,4}/m)解决了这个问题|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3118786|entityMap^0|2|K|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Just <code>text.scan(/.{1,4}/m)</code> resolves the problem

I have been looking for an elegant and efficient way to chunk a string into substrings of a given length in Ruby.

So far, the best I could come up with is this:

<pre><code>def chunk(string, size)
 (0..(string.length-1)/size).map{|i|string[i*size,size]}
end

&gt;&gt; chunk("abcdef",3)
=&gt; ["abc", "def"]
&gt;&gt; chunk("abcde",3)
=&gt; ["abc", "de"]
&gt;&gt; chunk("abc",3)
=&gt; ["abc"]
&gt;&gt; chunk("ab",3)
=&gt; ["ab"]
&gt;&gt; chunk("",3)
=&gt; []
</code></pre>

You might want <code>chunk("", n)</code> to return <code>[""]</code> instead of <code>[]</code>. If so, just add this as the first line of the method:

<pre><code>return [""] if string.empty?
</code></pre>

Would you recommend any better solution?

Edit

Thanks to Jeremy Ruten for this elegant and efficient solution: [edit: NOT efficient!]

<pre><code>def chunk(string, size)
 string.scan(/.{1,#{size}}/)
end
</code></pre>

Edit

The string.scan solution takes about 60 seconds to chop 512k into 1k chunks 10000 times, compared with the original slice-based solution which only takes 2.4 seconds.

What is the best way to chop a string into chunks of a given length in Ruby?

我一直在寻找一种优雅而高效的方法，在Ruby中将字符串分成给定长度的子字符串。到目前为止，我能想到的最好的结果是：def chunk(string, size)  (0..(string.length-1)/size).map{|i|string[i*size,size]}end>> chunk("abcdef",3)...

问在Ruby中，将字符串切成给定长度的块的最佳方法是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中，将字符串切成给定长度的块的最佳方法是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中，将字符串切成给定长度的块的最佳方法是什么？
EN