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

Question

我一直在寻找一种优雅而有效的方法来将 Ruby 中的字符串分成给定长度的子字符串。

到目前为止，我能想到的最好的办法是：

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

>> chunk("abcdef",3)
=> ["abc", "def"]
>> chunk("abcde",3)
=> ["abc", "de"]
>> chunk("abc",3)
=> ["abc"]
>> chunk("ab",3)
=> ["ab"]
>> chunk("",3)
=> []

您可能希望 chunk("", n) 返回 [""] 而不是 []。 如果是这样，只需将其添加为方法的第一行：

return [""] if string.empty?

您会推荐任何更好的解决方案吗？

编辑

感谢 Jeremy Ruten 提供了这个优雅而高效的解决方案：[编辑：效率不高！]

def chunk(string, size)
    string.scan(/.{1,#{size}}/)
end

编辑

string.scan 解决方案需要大约 60 秒将 512k 切成 1k 块 10000相比之下，原来基于切片的解决方案只需要 2.4 秒。

Answer 1

使用String#scan：

>> '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"]

Answer 2

这是另一种方法：

"abcdefghijklmnopqrstuvwxyz".chars.to_a.each_slice(3).to_a.map {|s| s.to_s }

或者，

"abcdefghijklmnopqrstuvwxyz".chars.each_slice(3).map(&:join)

或者：

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

Answer 3

倍数，我认为这是最有效的解决方案

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

如果您知道您的字符串是块大小和部分的

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

Answer 4

我做了一个小测试，将大约 593MB 的数据切成 18991 个 32KB 的块。
在我按下 ctrl+C 之前，您的 slice+map 版本使用 100% CPU 运行了至少 15 分钟。 这个版本使用 String#unpack 在 3.6 秒内完成：

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

Answer 5

这是针对稍微不同的情况的另一种解决方案，在处理大字符串时并且不需要一次存储所有块。 通过这种方式，它一次存储单个块，并且执行速度比切片字符串快得多：

io = StringIO.new(string)
until io.eof?
  chunk = io.read(chunk_size)
  do_something(chunk)
end

Answer 6

test.split(/(...)/).reject {|v| v.empty?}

拒绝是必要的，因为否则它包括组之间的空白。 我的 regex-fu 还不能立即解决这个问题。

Answer 7

一个更好的解决方案，考虑到字符串的最后部分可能小于块大小：

def chunk(inStr, sz)  
  return [inStr] if inStr.length < 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 << inStr[-m..-1] if (m % sz != 0) # add the last part 
  partial
end

Answer 8

您还有其他一些限制吗？ 否则我会非常想做一些简单的事情，比如

[0..10].each {
   str[(i*w),w]
}

Answer 9

只需 text.scan(/.{1,4}/m) 即可解决问题

Answer 10

我个人遵循 user8556428 的想法，以避免大多数提案引入的昂贵的中间值，并避免修改输入字符串。 我希望能够将它用作生成器（例如使用 s.each_slice.with_index ）。

我的用例实际上是关于字节，而不是字符。 对于字符大小，strscan 是一个很好的解决方案。

class String
    # Slices of fixed byte-length.  May cut multi-byte characters.
    def each_slice(n = 1000, &block)
        return if self.empty?

        if block_given?
            last = (self.length - 1) / n
            (0 .. last).each do |i|
                yield self.slice(i * n, n)
            end
        else
            enum_for(__method__, n)
        end
    end
end


p "abcdef".each_slice(3).to_a # => ["abc", "def"]   
p "abcde".each_slice(3).to_a  # => ["abc", "de"]    
p "abc".each_slice(3).to_a    # => ["abc"]          
p "ab".each_slice(3).to_a     # => ["ab"]           
p "".each_slice(3).to_a       # => []