Cách tốt nhất để cắt một chuỗi thành các đoạn có độ dài nhất định trong Ruby là gì?

Tôi đã tìm kiếm một cách thanh lịch và hiệu quả để phân đoạn một chuỗi thành các chuỗi con có độ dài nhất định trong Ruby.

Cho đến nay, điều tốt nhất tôi có thể nghĩ ra là:

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)
=> []

Bạn có thể muốn chunk("", n)quay lại [""]thay vì []. Nếu vậy, chỉ cần thêm dòng này làm dòng đầu tiên của phương thức:

return [""] if string.empty?

Bạn có đề xuất giải pháp nào tốt hơn không?

Biên tập

Cảm ơn Jeremy Ruten về giải pháp thanh lịch và hiệu quả này: [sửa: KHÔNG hiệu quả!]

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

Biên tập

Giải pháp string.scan mất khoảng 60 giây để cắt 512k thành 1k khối 10000 lần, so với giải pháp dựa trên lát cắt ban đầu chỉ mất 2,4 giây.

Sử dụng 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"]

Đây là một cách khác để làm điều đó:

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

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

Tôi nghĩ đây là giải pháp hiệu quả nhất nếu bạn biết chuỗi của mình là bội số của kích thước phân đoạn

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

và cho các bộ phận

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

Đây là một giải pháp khác cho trường hợp hơi khác, khi xử lý các chuỗi lớn và không cần phải lưu trữ tất cả các đoạn cùng một lúc. Bằng cách này, nó lưu trữ từng đoạn đơn lẻ và hoạt động nhanh hơn nhiều so với việc cắt các chuỗi:

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

Tôi đã thực hiện một thử nghiệm nhỏ để cắt khoảng 593MB dữ liệu thành 18991 mảnh 32KB. Phiên bản bản đồ + lát cắt của bạn đã chạy trong ít nhất 15 phút sử dụng 100% CPU trước khi tôi nhấn ctrl + C. Phiên bản này sử dụng String # unpack đã hoàn thành trong 3,6 giây:

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

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

Việc loại bỏ là cần thiết vì nó bao gồm khoảng trống giữa các tập hợp. Regex-fu của tôi không khá lắm để biết cách khắc phục điều đó ngay trên đỉnh đầu của tôi.

Một giải pháp tốt hơn có tính đến phần cuối cùng của chuỗi có thể nhỏ hơn kích thước đoạn:

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

Bạn có nghĩ đến một số ràng buộc khác không? Nếu không, tôi sẽ rất muốn làm một điều gì đó đơn giản như

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

Chỉ cần text.scan(/.{1,4}/m)giải quyết vấn đề